/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaAccess.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaAccess.cpp
Warning:	line 1260, column 34 Access to field 'Base' results in a dereference of a null pointer (loaded from variable 'constrainingBase')

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 SemaAccess.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/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/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/libclangSema/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/libclangSema/../../../llvm/clang/lib/Sema/SemaAccess.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaAccess.cpp

→

1//===---- SemaAccess.cpp - C++ Access Control -------------------*- 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 provides Sema routines for C++ access control semantics.
10//
11//===----------------------------------------------------------------------===//

13#include "clang/Basic/Specifiers.h"
14#include "clang/Sema/SemaInternal.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/CXXInheritance.h"
17#include "clang/AST/DeclCXX.h"
18#include "clang/AST/DeclFriend.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DependentDiagnostic.h"
21#include "clang/AST/ExprCXX.h"
22#include "clang/Sema/DelayedDiagnostic.h"
23#include "clang/Sema/Initialization.h"
24#include "clang/Sema/Lookup.h"

26using namespace clang;
27using namespace sema;

29/// A copy of Sema's enum without AR_delayed.
30enum AccessResult {
AR_accessible,
AR_inaccessible,
AR_dependent
34};

36/// SetMemberAccessSpecifier - Set the access specifier of a member.
37/// Returns true on error (when the previous member decl access specifier
38/// is different from the new member decl access specifier).
39bool Sema::SetMemberAccessSpecifier(NamedDecl *MemberDecl,
                                  NamedDecl *PrevMemberDecl,
                                  AccessSpecifier LexicalAS) {
if (!PrevMemberDecl) {
  // Use the lexical access specifier.
  MemberDecl->setAccess(LexicalAS);
  return false;
}

// C++ [class.access.spec]p3: When a member is redeclared its access
// specifier must be same as its initial declaration.
if (LexicalAS != AS_none && LexicalAS != PrevMemberDecl->getAccess()) {
  Diag(MemberDecl->getLocation(),
       diag::err_class_redeclared_with_different_access)
    << MemberDecl << LexicalAS;
  Diag(PrevMemberDecl->getLocation(), diag::note_previous_access_declaration)
    << PrevMemberDecl << PrevMemberDecl->getAccess();

  MemberDecl->setAccess(LexicalAS);
  return true;
}

MemberDecl->setAccess(PrevMemberDecl->getAccess());
return false;
63}

65static CXXRecordDecl *FindDeclaringClass(NamedDecl *D) {
DeclContext *DC = D->getDeclContext();

// This can only happen at top: enum decls only "publish" their
// immediate members.
if (isa<EnumDecl>(DC))
  DC = cast<EnumDecl>(DC)->getDeclContext();

CXXRecordDecl *DeclaringClass = cast<CXXRecordDecl>(DC);
while (DeclaringClass->isAnonymousStructOrUnion())
  DeclaringClass = cast<CXXRecordDecl>(DeclaringClass->getDeclContext());
return DeclaringClass;
77}

79namespace {
80struct EffectiveContext {
EffectiveContext() : Inner(nullptr), Dependent(false) {}

explicit EffectiveContext(DeclContext *DC)
  : Inner(DC),
    Dependent(DC->isDependentContext()) {

  // An implicit deduction guide is semantically in the context enclosing the
  // class template, but for access purposes behaves like the constructor
  // from which it was produced.
  if (auto *DGD = dyn_cast<CXXDeductionGuideDecl>(DC)) {
    if (DGD->isImplicit()) {
      DC = DGD->getCorrespondingConstructor();
      if (!DC) {
        // The copy deduction candidate doesn't have a corresponding
        // constructor.
        DC = cast<DeclContext>(DGD->getDeducedTemplate()->getTemplatedDecl());
      }
    }
  }

  // C++11 [class.access.nest]p1:
  //   A nested class is a member and as such has the same access
  //   rights as any other member.
  // C++11 [class.access]p2:
  //   A member of a class can also access all the names to which
  //   the class has access.  A local class of a member function
  //   may access the same names that the member function itself
  //   may access.
  // This almost implies that the privileges of nesting are transitive.
  // Technically it says nothing about the local classes of non-member
  // functions (which can gain privileges through friendship), but we
  // take that as an oversight.
  while (true) {
    // We want to add canonical declarations to the EC lists for
    // simplicity of checking, but we need to walk up through the
    // actual current DC chain.  Otherwise, something like a local
    // extern or friend which happens to be the canonical
    // declaration will really mess us up.

    if (isa<CXXRecordDecl>(DC)) {
      CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
      Records.push_back(Record->getCanonicalDecl());
      DC = Record->getDeclContext();
    } else if (isa<FunctionDecl>(DC)) {
      FunctionDecl *Function = cast<FunctionDecl>(DC);
      Functions.push_back(Function->getCanonicalDecl());
      if (Function->getFriendObjectKind())
        DC = Function->getLexicalDeclContext();
      else
        DC = Function->getDeclContext();
    } else if (DC->isFileContext()) {
      break;
    } else {
      DC = DC->getParent();
    }
  }
}

bool isDependent() const { return Dependent; }

bool includesClass(const CXXRecordDecl *R) const {
  R = R->getCanonicalDecl();
  return llvm::find(Records, R) != Records.end();
}

/// Retrieves the innermost "useful" context.  Can be null if we're
/// doing access-control without privileges.
DeclContext *getInnerContext() const {
  return Inner;
}

typedef SmallVectorImpl<CXXRecordDecl*>::const_iterator record_iterator;

DeclContext *Inner;
SmallVector<FunctionDecl*, 4> Functions;
SmallVector<CXXRecordDecl*, 4> Records;
bool Dependent;
158};

160/// Like sema::AccessedEntity, but kindly lets us scribble all over
161/// it.
162struct AccessTarget : public AccessedEntity {
AccessTarget(const AccessedEntity &Entity)
  : AccessedEntity(Entity) {
  initialize();
}

AccessTarget(ASTContext &Context,
             MemberNonce _,
             CXXRecordDecl *NamingClass,
             DeclAccessPair FoundDecl,
             QualType BaseObjectType)
  : AccessedEntity(Context.getDiagAllocator(), Member, NamingClass,
                   FoundDecl, BaseObjectType) {
  initialize();
}

AccessTarget(ASTContext &Context,
             BaseNonce _,
             CXXRecordDecl *BaseClass,
             CXXRecordDecl *DerivedClass,
             AccessSpecifier Access)
  : AccessedEntity(Context.getDiagAllocator(), Base, BaseClass, DerivedClass,
                   Access) {
  initialize();
}

bool isInstanceMember() const {
  return (isMemberAccess() && getTargetDecl()->isCXXInstanceMember());
}

bool hasInstanceContext() const {
  return HasInstanceContext;
}

class SavedInstanceContext {
public:
  SavedInstanceContext(SavedInstanceContext &&S)
      : Target(S.Target), Has(S.Has) {
    S.Target = nullptr;
  }
  ~SavedInstanceContext() {
    if (Target)
      Target->HasInstanceContext = Has;
  }

private:
  friend struct AccessTarget;
  explicit SavedInstanceContext(AccessTarget &Target)
      : Target(&Target), Has(Target.HasInstanceContext) {}
  AccessTarget *Target;
  bool Has;
};

SavedInstanceContext saveInstanceContext() {
  return SavedInstanceContext(*this);
}

void suppressInstanceContext() {
  HasInstanceContext = false;
}

const CXXRecordDecl *resolveInstanceContext(Sema &S) const {
  assert(HasInstanceContext)((void)0);
  if (CalculatedInstanceContext)
    return InstanceContext;

  CalculatedInstanceContext = true;
  DeclContext *IC = S.computeDeclContext(getBaseObjectType());
  InstanceContext = (IC ? cast<CXXRecordDecl>(IC)->getCanonicalDecl()
                        : nullptr);
  return InstanceContext;
}

const CXXRecordDecl *getDeclaringClass() const {
  return DeclaringClass;
}

/// The "effective" naming class is the canonical non-anonymous
/// class containing the actual naming class.
const CXXRecordDecl *getEffectiveNamingClass() const {
  const CXXRecordDecl *namingClass = getNamingClass();
  while (namingClass->isAnonymousStructOrUnion())
    namingClass = cast<CXXRecordDecl>(namingClass->getParent());
  return namingClass->getCanonicalDecl();
}

248private:
void initialize() {
  HasInstanceContext = (isMemberAccess() &&
                        !getBaseObjectType().isNull() &&
                        getTargetDecl()->isCXXInstanceMember());
  CalculatedInstanceContext = false;
  InstanceContext = nullptr;

  if (isMemberAccess())
    DeclaringClass = FindDeclaringClass(getTargetDecl());
  else
    DeclaringClass = getBaseClass();
  DeclaringClass = DeclaringClass->getCanonicalDecl();
}

bool HasInstanceContext : 1;
mutable bool CalculatedInstanceContext : 1;
mutable const CXXRecordDecl *InstanceContext;
const CXXRecordDecl *DeclaringClass;
267};

269}

271/// Checks whether one class might instantiate to the other.
272static bool MightInstantiateTo(const CXXRecordDecl *From,
                             const CXXRecordDecl *To) {
// Declaration names are always preserved by instantiation.
if (From->getDeclName() != To->getDeclName())
  return false;

const DeclContext *FromDC = From->getDeclContext()->getPrimaryContext();
const DeclContext *ToDC = To->getDeclContext()->getPrimaryContext();
if (FromDC == ToDC) return true;
if (FromDC->isFileContext() || ToDC->isFileContext()) return false;

// Be conservative.
return true;
285}

287/// Checks whether one class is derived from another, inclusively.
288/// Properly indicates when it couldn't be determined due to
289/// dependence.
290///
291/// This should probably be donated to AST or at least Sema.
292static AccessResult IsDerivedFromInclusive(const CXXRecordDecl *Derived,
                                         const CXXRecordDecl *Target) {
assert(Derived->getCanonicalDecl() == Derived)((void)0);
assert(Target->getCanonicalDecl() == Target)((void)0);

if (Derived == Target) return AR_accessible;

bool CheckDependent = Derived->isDependentContext();
if (CheckDependent && MightInstantiateTo(Derived, Target))
  return AR_dependent;

AccessResult OnFailure = AR_inaccessible;
SmallVector<const CXXRecordDecl*, 8> Queue; // actually a stack

while (true) {
  if (Derived->isDependentContext() && !Derived->hasDefinition() &&
      !Derived->isLambda())
    return AR_dependent;

  for (const auto &I : Derived->bases()) {
    const CXXRecordDecl *RD;

    QualType T = I.getType();
    if (const RecordType *RT = T->getAs<RecordType>()) {
      RD = cast<CXXRecordDecl>(RT->getDecl());
    } else if (const InjectedClassNameType *IT
                 = T->getAs<InjectedClassNameType>()) {
      RD = IT->getDecl();
    } else {
      assert(T->isDependentType() && "non-dependent base wasn't a record?")((void)0);
      OnFailure = AR_dependent;
      continue;
    }

    RD = RD->getCanonicalDecl();
    if (RD == Target) return AR_accessible;
    if (CheckDependent && MightInstantiateTo(RD, Target))
      OnFailure = AR_dependent;

    Queue.push_back(RD);
  }

  if (Queue.empty()) break;

  Derived = Queue.pop_back_val();
}

return OnFailure;
340}


343static bool MightInstantiateTo(Sema &S, DeclContext *Context,
                             DeclContext *Friend) {
if (Friend == Context)
  return true;

assert(!Friend->isDependentContext() &&((void)0)
       "can't handle friends with dependent contexts here")((void)0);

if (!Context->isDependentContext())
  return false;

if (Friend->isFileContext())
  return false;

// TODO: this is very conservative
return true;
359}

361// Asks whether the type in 'context' can ever instantiate to the type
362// in 'friend'.
363static bool MightInstantiateTo(Sema &S, CanQualType Context, CanQualType Friend) {
if (Friend == Context)
  return true;

if (!Friend->isDependentType() && !Context->isDependentType())
  return false;

// TODO: this is very conservative.
return true;
372}

374static bool MightInstantiateTo(Sema &S,
                             FunctionDecl *Context,
                             FunctionDecl *Friend) {
if (Context->getDeclName() != Friend->getDeclName())
  return false;

if (!MightInstantiateTo(S,
                        Context->getDeclContext(),
                        Friend->getDeclContext()))
  return false;

CanQual<FunctionProtoType> FriendTy
  = S.Context.getCanonicalType(Friend->getType())
       ->getAs<FunctionProtoType>();
CanQual<FunctionProtoType> ContextTy
  = S.Context.getCanonicalType(Context->getType())
       ->getAs<FunctionProtoType>();

// There isn't any way that I know of to add qualifiers
// during instantiation.
if (FriendTy.getQualifiers() != ContextTy.getQualifiers())
  return false;

if (FriendTy->getNumParams() != ContextTy->getNumParams())
  return false;

if (!MightInstantiateTo(S, ContextTy->getReturnType(),
                        FriendTy->getReturnType()))
  return false;

for (unsigned I = 0, E = FriendTy->getNumParams(); I != E; ++I)
  if (!MightInstantiateTo(S, ContextTy->getParamType(I),
                          FriendTy->getParamType(I)))
    return false;

return true;
410}

412static bool MightInstantiateTo(Sema &S,
                             FunctionTemplateDecl *Context,
                             FunctionTemplateDecl *Friend) {
return MightInstantiateTo(S,
                          Context->getTemplatedDecl(),
                          Friend->getTemplatedDecl());
418}

420static AccessResult MatchesFriend(Sema &S,
                                const EffectiveContext &EC,
                                const CXXRecordDecl *Friend) {
if (EC.includesClass(Friend))
  return AR_accessible;

if (EC.isDependent()) {
  for (const CXXRecordDecl *Context : EC.Records) {
    if (MightInstantiateTo(Context, Friend))
      return AR_dependent;
  }
}

return AR_inaccessible;
434}

436static AccessResult MatchesFriend(Sema &S,
                                const EffectiveContext &EC,
                                CanQualType Friend) {
if (const RecordType *RT = Friend->getAs<RecordType>())
  return MatchesFriend(S, EC, cast<CXXRecordDecl>(RT->getDecl()));

// TODO: we can do better than this
if (Friend->isDependentType())
  return AR_dependent;

return AR_inaccessible;
447}

449/// Determines whether the given friend class template matches
450/// anything in the effective context.
451static AccessResult MatchesFriend(Sema &S,
                                const EffectiveContext &EC,
                                ClassTemplateDecl *Friend) {
AccessResult OnFailure = AR_inaccessible;

// Check whether the friend is the template of a class in the
// context chain.
for (SmallVectorImpl<CXXRecordDecl*>::const_iterator
       I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {
  CXXRecordDecl *Record = *I;

  // Figure out whether the current class has a template:
  ClassTemplateDecl *CTD;

  // A specialization of the template...
  if (isa<ClassTemplateSpecializationDecl>(Record)) {
    CTD = cast<ClassTemplateSpecializationDecl>(Record)
      ->getSpecializedTemplate();

  // ... or the template pattern itself.
  } else {
    CTD = Record->getDescribedClassTemplate();
    if (!CTD) continue;
  }

  // It's a match.
  if (Friend == CTD->getCanonicalDecl())
    return AR_accessible;

  // If the context isn't dependent, it can't be a dependent match.
  if (!EC.isDependent())
    continue;

  // If the template names don't match, it can't be a dependent
  // match.
  if (CTD->getDeclName() != Friend->getDeclName())
    continue;

  // If the class's context can't instantiate to the friend's
  // context, it can't be a dependent match.
  if (!MightInstantiateTo(S, CTD->getDeclContext(),
                          Friend->getDeclContext()))
    continue;

  // Otherwise, it's a dependent match.
  OnFailure = AR_dependent;
}

return OnFailure;
500}

502/// Determines whether the given friend function matches anything in
503/// the effective context.
504static AccessResult MatchesFriend(Sema &S,
                                const EffectiveContext &EC,
                                FunctionDecl *Friend) {
AccessResult OnFailure = AR_inaccessible;

for (SmallVectorImpl<FunctionDecl*>::const_iterator
       I = EC.Functions.begin(), E = EC.Functions.end(); I != E; ++I) {
  if (Friend == *I)
    return AR_accessible;

  if (EC.isDependent() && MightInstantiateTo(S, *I, Friend))
    OnFailure = AR_dependent;
}

return OnFailure;
519}

521/// Determines whether the given friend function template matches
522/// anything in the effective context.
523static AccessResult MatchesFriend(Sema &S,
                                const EffectiveContext &EC,
                                FunctionTemplateDecl *Friend) {
if (EC.Functions.empty()) return AR_inaccessible;

AccessResult OnFailure = AR_inaccessible;

for (SmallVectorImpl<FunctionDecl*>::const_iterator
       I = EC.Functions.begin(), E = EC.Functions.end(); I != E; ++I) {

  FunctionTemplateDecl *FTD = (*I)->getPrimaryTemplate();
  if (!FTD)
    FTD = (*I)->getDescribedFunctionTemplate();
  if (!FTD)
    continue;

  FTD = FTD->getCanonicalDecl();

  if (Friend == FTD)
    return AR_accessible;

  if (EC.isDependent() && MightInstantiateTo(S, FTD, Friend))
    OnFailure = AR_dependent;
}

return OnFailure;
549}

551/// Determines whether the given friend declaration matches anything
552/// in the effective context.
553static AccessResult MatchesFriend(Sema &S,
                                const EffectiveContext &EC,
                                FriendDecl *FriendD) {
// Whitelist accesses if there's an invalid or unsupported friend
// declaration.
if (FriendD->isInvalidDecl() || FriendD->isUnsupportedFriend())
  return AR_accessible;

if (TypeSourceInfo *T = FriendD->getFriendType())
  return MatchesFriend(S, EC, T->getType()->getCanonicalTypeUnqualified());

NamedDecl *Friend
  = cast<NamedDecl>(FriendD->getFriendDecl()->getCanonicalDecl());

// FIXME: declarations with dependent or templated scope.

if (isa<ClassTemplateDecl>(Friend))
  return MatchesFriend(S, EC, cast<ClassTemplateDecl>(Friend));

if (isa<FunctionTemplateDecl>(Friend))
  return MatchesFriend(S, EC, cast<FunctionTemplateDecl>(Friend));

if (isa<CXXRecordDecl>(Friend))
  return MatchesFriend(S, EC, cast<CXXRecordDecl>(Friend));

assert(isa<FunctionDecl>(Friend) && "unknown friend decl kind")((void)0);
return MatchesFriend(S, EC, cast<FunctionDecl>(Friend));
580}

582static AccessResult GetFriendKind(Sema &S,
                                const EffectiveContext &EC,
                                const CXXRecordDecl *Class) {
AccessResult OnFailure = AR_inaccessible;

// Okay, check friends.
for (auto *Friend : Class->friends()) {
  switch (MatchesFriend(S, EC, Friend)) {
  case AR_accessible:
    return AR_accessible;

  case AR_inaccessible:
    continue;

  case AR_dependent:
    OnFailure = AR_dependent;
    break;
  }
}

// That's it, give up.
return OnFailure;
604}

606namespace {

608/// A helper class for checking for a friend which will grant access
609/// to a protected instance member.
610struct ProtectedFriendContext {
Sema &S;
const EffectiveContext &EC;
const CXXRecordDecl *NamingClass;
bool CheckDependent;
bool EverDependent;

/// The path down to the current base class.
SmallVector<const CXXRecordDecl*, 20> CurPath;

ProtectedFriendContext(Sema &S, const EffectiveContext &EC,
                       const CXXRecordDecl *InstanceContext,
                       const CXXRecordDecl *NamingClass)
  : S(S), EC(EC), NamingClass(NamingClass),
    CheckDependent(InstanceContext->isDependentContext() ||
                   NamingClass->isDependentContext()),
    EverDependent(false) {}

/// Check classes in the current path for friendship, starting at
/// the given index.
bool checkFriendshipAlongPath(unsigned I) {
  assert(I < CurPath.size())((void)0);
  for (unsigned E = CurPath.size(); I != E; ++I) {
    switch (GetFriendKind(S, EC, CurPath[I])) {
    case AR_accessible:   return true;
    case AR_inaccessible: continue;
    case AR_dependent:    EverDependent = true; continue;
    }
  }
  return false;
}

/// Perform a search starting at the given class.
///
/// PrivateDepth is the index of the last (least derived) class
/// along the current path such that a notional public member of
/// the final class in the path would have access in that class.
bool findFriendship(const CXXRecordDecl *Cur, unsigned PrivateDepth) {
  // If we ever reach the naming class, check the current path for
  // friendship.  We can also stop recursing because we obviously
  // won't find the naming class there again.
  if (Cur == NamingClass)
    return checkFriendshipAlongPath(PrivateDepth);

  if (CheckDependent && MightInstantiateTo(Cur, NamingClass))
    EverDependent = true;

  // Recurse into the base classes.
  for (const auto &I : Cur->bases()) {
    // If this is private inheritance, then a public member of the
    // base will not have any access in classes derived from Cur.
    unsigned BasePrivateDepth = PrivateDepth;
    if (I.getAccessSpecifier() == AS_private)
      BasePrivateDepth = CurPath.size() - 1;

    const CXXRecordDecl *RD;

    QualType T = I.getType();
    if (const RecordType *RT = T->getAs<RecordType>()) {
      RD = cast<CXXRecordDecl>(RT->getDecl());
    } else if (const InjectedClassNameType *IT
                 = T->getAs<InjectedClassNameType>()) {
      RD = IT->getDecl();
    } else {
      assert(T->isDependentType() && "non-dependent base wasn't a record?")((void)0);
      EverDependent = true;
      continue;
    }

    // Recurse.  We don't need to clean up if this returns true.
    CurPath.push_back(RD);
    if (findFriendship(RD->getCanonicalDecl(), BasePrivateDepth))
      return true;
    CurPath.pop_back();
  }

  return false;
}

bool findFriendship(const CXXRecordDecl *Cur) {
  assert(CurPath.empty())((void)0);
  CurPath.push_back(Cur);
  return findFriendship(Cur, 0);
}
694};
695}

697/// Search for a class P that EC is a friend of, under the constraint
698///   InstanceContext <= P
699/// if InstanceContext exists, or else
700///   NamingClass <= P
701/// and with the additional restriction that a protected member of
702/// NamingClass would have some natural access in P, which implicitly
703/// imposes the constraint that P <= NamingClass.
704///
705/// This isn't quite the condition laid out in the standard.
706/// Instead of saying that a notional protected member of NamingClass
707/// would have to have some natural access in P, it says the actual
708/// target has to have some natural access in P, which opens up the
709/// possibility that the target (which is not necessarily a member
710/// of NamingClass) might be more accessible along some path not
711/// passing through it.  That's really a bad idea, though, because it
712/// introduces two problems:
713///   - Most importantly, it breaks encapsulation because you can
714///     access a forbidden base class's members by directly subclassing
715///     it elsewhere.
716///   - It also makes access substantially harder to compute because it
717///     breaks the hill-climbing algorithm: knowing that the target is
718///     accessible in some base class would no longer let you change
719///     the question solely to whether the base class is accessible,
720///     because the original target might have been more accessible
721///     because of crazy subclassing.
722/// So we don't implement that.
723static AccessResult GetProtectedFriendKind(Sema &S, const EffectiveContext &EC,
                                         const CXXRecordDecl *InstanceContext,
                                         const CXXRecordDecl *NamingClass) {
assert(InstanceContext == nullptr ||((void)0)
       InstanceContext->getCanonicalDecl() == InstanceContext)((void)0);
assert(NamingClass->getCanonicalDecl() == NamingClass)((void)0);

// If we don't have an instance context, our constraints give us
// that NamingClass <= P <= NamingClass, i.e. P == NamingClass.
// This is just the usual friendship check.
if (!InstanceContext) return GetFriendKind(S, EC, NamingClass);

ProtectedFriendContext PRC(S, EC, InstanceContext, NamingClass);
if (PRC.findFriendship(InstanceContext)) return AR_accessible;
if (PRC.EverDependent) return AR_dependent;
return AR_inaccessible;
739}

741static AccessResult HasAccess(Sema &S,
                            const EffectiveContext &EC,
                            const CXXRecordDecl *NamingClass,
                            AccessSpecifier Access,
                            const AccessTarget &Target) {
assert(NamingClass->getCanonicalDecl() == NamingClass &&((void)0)
       "declaration should be canonicalized before being passed here")((void)0);

if (Access == AS_public) return AR_accessible;
assert(Access == AS_private || Access == AS_protected)((void)0);

AccessResult OnFailure = AR_inaccessible;

for (EffectiveContext::record_iterator
       I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {
  // All the declarations in EC have been canonicalized, so pointer
  // equality from this point on will work fine.
  const CXXRecordDecl *ECRecord = *I;

  // [B2] and [M2]
  if (Access == AS_private) {
    if (ECRecord == NamingClass)
      return AR_accessible;

    if (EC.isDependent() && MightInstantiateTo(ECRecord, NamingClass))
      OnFailure = AR_dependent;

  // [B3] and [M3]
  } else {
    assert(Access == AS_protected)((void)0);
    switch (IsDerivedFromInclusive(ECRecord, NamingClass)) {
    case AR_accessible: break;
    case AR_inaccessible: continue;
    case AR_dependent: OnFailure = AR_dependent; continue;
    }

    // C++ [class.protected]p1:
    //   An additional access check beyond those described earlier in
    //   [class.access] is applied when a non-static data member or
    //   non-static member function is a protected member of its naming
    //   class.  As described earlier, access to a protected member is
    //   granted because the reference occurs in a friend or member of
    //   some class C.  If the access is to form a pointer to member,
    //   the nested-name-specifier shall name C or a class derived from
    //   C. All other accesses involve a (possibly implicit) object
    //   expression. In this case, the class of the object expression
    //   shall be C or a class derived from C.
    //
    // We interpret this as a restriction on [M3].

    // In this part of the code, 'C' is just our context class ECRecord.

    // These rules are different if we don't have an instance context.
    if (!Target.hasInstanceContext()) {
      // If it's not an instance member, these restrictions don't apply.
      if (!Target.isInstanceMember()) return AR_accessible;

      // If it's an instance member, use the pointer-to-member rule
      // that the naming class has to be derived from the effective
      // context.

      // Emulate a MSVC bug where the creation of pointer-to-member
      // to protected member of base class is allowed but only from
      // static member functions.
      if (S.getLangOpts().MSVCCompat && !EC.Functions.empty())
        if (CXXMethodDecl* MD = dyn_cast<CXXMethodDecl>(EC.Functions.front()))
          if (MD->isStatic()) return AR_accessible;

      // Despite the standard's confident wording, there is a case
      // where you can have an instance member that's neither in a
      // pointer-to-member expression nor in a member access:  when
      // it names a field in an unevaluated context that can't be an
      // implicit member.  Pending clarification, we just apply the
      // same naming-class restriction here.
      //   FIXME: we're probably not correctly adding the
      //   protected-member restriction when we retroactively convert
      //   an expression to being evaluated.

      // We know that ECRecord derives from NamingClass.  The
      // restriction says to check whether NamingClass derives from
      // ECRecord, but that's not really necessary: two distinct
      // classes can't be recursively derived from each other.  So
      // along this path, we just need to check whether the classes
      // are equal.
      if (NamingClass == ECRecord) return AR_accessible;

      // Otherwise, this context class tells us nothing;  on to the next.
      continue;
    }

    assert(Target.isInstanceMember())((void)0);

    const CXXRecordDecl *InstanceContext = Target.resolveInstanceContext(S);
    if (!InstanceContext) {
      OnFailure = AR_dependent;
      continue;
    }

    switch (IsDerivedFromInclusive(InstanceContext, ECRecord)) {
    case AR_accessible: return AR_accessible;
    case AR_inaccessible: continue;
    case AR_dependent: OnFailure = AR_dependent; continue;
    }
  }
}

// [M3] and [B3] say that, if the target is protected in N, we grant
// access if the access occurs in a friend or member of some class P
// that's a subclass of N and where the target has some natural
// access in P.  The 'member' aspect is easy to handle because P
// would necessarily be one of the effective-context records, and we
// address that above.  The 'friend' aspect is completely ridiculous
// to implement because there are no restrictions at all on P
// *unless* the [class.protected] restriction applies.  If it does,
// however, we should ignore whether the naming class is a friend,
// and instead rely on whether any potential P is a friend.
if (Access == AS_protected && Target.isInstanceMember()) {
  // Compute the instance context if possible.
  const CXXRecordDecl *InstanceContext = nullptr;
  if (Target.hasInstanceContext()) {
    InstanceContext = Target.resolveInstanceContext(S);
    if (!InstanceContext) return AR_dependent;
  }

  switch (GetProtectedFriendKind(S, EC, InstanceContext, NamingClass)) {
  case AR_accessible: return AR_accessible;
  case AR_inaccessible: return OnFailure;
  case AR_dependent: return AR_dependent;
  }
  llvm_unreachable("impossible friendship kind")__builtin_unreachable();
}

switch (GetFriendKind(S, EC, NamingClass)) {
case AR_accessible: return AR_accessible;
case AR_inaccessible: return OnFailure;
case AR_dependent: return AR_dependent;
}

// Silence bogus warnings
llvm_unreachable("impossible friendship kind")__builtin_unreachable();
881}

883/// Finds the best path from the naming class to the declaring class,
884/// taking friend declarations into account.
885///
886/// C++0x [class.access.base]p5:
887///   A member m is accessible at the point R when named in class N if
888///   [M1] m as a member of N is public, or
889///   [M2] m as a member of N is private, and R occurs in a member or
890///        friend of class N, or
891///   [M3] m as a member of N is protected, and R occurs in a member or
892///        friend of class N, or in a member or friend of a class P
893///        derived from N, where m as a member of P is public, private,
894///        or protected, or
895///   [M4] there exists a base class B of N that is accessible at R, and
896///        m is accessible at R when named in class B.
897///
898/// C++0x [class.access.base]p4:
899///   A base class B of N is accessible at R, if
900///   [B1] an invented public member of B would be a public member of N, or
901///   [B2] R occurs in a member or friend of class N, and an invented public
902///        member of B would be a private or protected member of N, or
903///   [B3] R occurs in a member or friend of a class P derived from N, and an
904///        invented public member of B would be a private or protected member
905///        of P, or
906///   [B4] there exists a class S such that B is a base class of S accessible
907///        at R and S is a base class of N accessible at R.
908///
909/// Along a single inheritance path we can restate both of these
910/// iteratively:
911///
912/// First, we note that M1-4 are equivalent to B1-4 if the member is
913/// treated as a notional base of its declaring class with inheritance
914/// access equivalent to the member's access.  Therefore we need only
915/// ask whether a class B is accessible from a class N in context R.
916///
917/// Let B_1 .. B_n be the inheritance path in question (i.e. where
918/// B_1 = N, B_n = B, and for all i, B_{i+1} is a direct base class of
919/// B_i).  For i in 1..n, we will calculate ACAB(i), the access to the
920/// closest accessible base in the path:
921///   Access(a, b) = (* access on the base specifier from a to b *)
922///   Merge(a, forbidden) = forbidden
923///   Merge(a, private) = forbidden
924///   Merge(a, b) = min(a,b)
925///   Accessible(c, forbidden) = false
926///   Accessible(c, private) = (R is c) || IsFriend(c, R)
927///   Accessible(c, protected) = (R derived from c) || IsFriend(c, R)
928///   Accessible(c, public) = true
929///   ACAB(n) = public
930///   ACAB(i) =
931///     let AccessToBase = Merge(Access(B_i, B_{i+1}), ACAB(i+1)) in
932///     if Accessible(B_i, AccessToBase) then public else AccessToBase
933///
934/// B is an accessible base of N at R iff ACAB(1) = public.
935///
936/// \param FinalAccess the access of the "final step", or AS_public if
937///   there is no final step.
938/// \return null if friendship is dependent
939static CXXBasePath *FindBestPath(Sema &S,
                               const EffectiveContext &EC,
                               AccessTarget &Target,
                               AccessSpecifier FinalAccess,
                               CXXBasePaths &Paths) {
// Derive the paths to the desired base.
const CXXRecordDecl *Derived = Target.getNamingClass();
const CXXRecordDecl *Base = Target.getDeclaringClass();

// FIXME: fail correctly when there are dependent paths.
bool isDerived = Derived->isDerivedFrom(const_cast<CXXRecordDecl*>(Base),
                                        Paths);
assert(isDerived && "derived class not actually derived from base")((void)0);
(void) isDerived;

CXXBasePath *BestPath = nullptr;

assert(FinalAccess != AS_none && "forbidden access after declaring class")((void)0);

bool AnyDependent = false;

// Derive the friend-modified access along each path.
for (CXXBasePaths::paths_iterator PI = Paths.begin(), PE = Paths.end();
       PI != PE; ++PI) {
  AccessTarget::SavedInstanceContext _ = Target.saveInstanceContext();

  // Walk through the path backwards.
  AccessSpecifier PathAccess = FinalAccess;
  CXXBasePath::iterator I = PI->end(), E = PI->begin();
  while (I != E) {
    --I;

    assert(PathAccess != AS_none)((void)0);

    // If the declaration is a private member of a base class, there
    // is no level of friendship in derived classes that can make it
    // accessible.
    if (PathAccess == AS_private) {
      PathAccess = AS_none;
      break;
    }

    const CXXRecordDecl *NC = I->Class->getCanonicalDecl();

    AccessSpecifier BaseAccess = I->Base->getAccessSpecifier();
    PathAccess = std::max(PathAccess, BaseAccess);

    switch (HasAccess(S, EC, NC, PathAccess, Target)) {
    case AR_inaccessible: break;
    case AR_accessible:
      PathAccess = AS_public;

      // Future tests are not against members and so do not have
      // instance context.
      Target.suppressInstanceContext();
      break;
    case AR_dependent:
      AnyDependent = true;
      goto Next;
    }
  }

  // Note that we modify the path's Access field to the
  // friend-modified access.
  if (BestPath == nullptr || PathAccess < BestPath->Access) {
    BestPath = &*PI;
    BestPath->Access = PathAccess;

    // Short-circuit if we found a public path.
    if (BestPath->Access == AS_public)
      return BestPath;
  }

Next: ;
}

assert((!BestPath || BestPath->Access != AS_public) &&((void)0)
       "fell out of loop with public path")((void)0);

// We didn't find a public path, but at least one path was subject
// to dependent friendship, so delay the check.
if (AnyDependent)
  return nullptr;

return BestPath;
1024}

1026/// Given that an entity has protected natural access, check whether
1027/// access might be denied because of the protected member access
1028/// restriction.
1029///
1030/// \return true if a note was emitted
1031static bool TryDiagnoseProtectedAccess(Sema &S, const EffectiveContext &EC,
                                     AccessTarget &Target) {
// Only applies to instance accesses.
if (!Target.isInstanceMember())
  return false;

assert(Target.isMemberAccess())((void)0);

const CXXRecordDecl *NamingClass = Target.getEffectiveNamingClass();

for (EffectiveContext::record_iterator
       I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {
  const CXXRecordDecl *ECRecord = *I;
  switch (IsDerivedFromInclusive(ECRecord, NamingClass)) {
  case AR_accessible: break;
  case AR_inaccessible: continue;
  case AR_dependent: continue;
  }

  // The effective context is a subclass of the declaring class.
  // Check whether the [class.protected] restriction is limiting
  // access.

  // To get this exactly right, this might need to be checked more
  // holistically;  it's not necessarily the case that gaining
  // access here would grant us access overall.

  NamedDecl *D = Target.getTargetDecl();

  // If we don't have an instance context, [class.protected] says the
  // naming class has to equal the context class.
  if (!Target.hasInstanceContext()) {
    // If it does, the restriction doesn't apply.
    if (NamingClass == ECRecord) continue;

    // TODO: it would be great to have a fixit here, since this is
    // such an obvious error.
    S.Diag(D->getLocation(), diag::note_access_protected_restricted_noobject)
      << S.Context.getTypeDeclType(ECRecord);
    return true;
  }

  const CXXRecordDecl *InstanceContext = Target.resolveInstanceContext(S);
  assert(InstanceContext && "diagnosing dependent access")((void)0);

  switch (IsDerivedFromInclusive(InstanceContext, ECRecord)) {
  case AR_accessible: continue;
  case AR_dependent: continue;
  case AR_inaccessible:
    break;
  }

  // Okay, the restriction seems to be what's limiting us.

  // Use a special diagnostic for constructors and destructors.
  if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D) ||
      (isa<FunctionTemplateDecl>(D) &&
       isa<CXXConstructorDecl>(
              cast<FunctionTemplateDecl>(D)->getTemplatedDecl()))) {
    return S.Diag(D->getLocation(),
                  diag::note_access_protected_restricted_ctordtor)
           << isa<CXXDestructorDecl>(D->getAsFunction());
  }

  // Otherwise, use the generic diagnostic.
  return S.Diag(D->getLocation(),
                diag::note_access_protected_restricted_object)
         << S.Context.getTypeDeclType(ECRecord);
}

return false;
1102}

1104/// We are unable to access a given declaration due to its direct
1105/// access control;  diagnose that.
1106static void diagnoseBadDirectAccess(Sema &S,
                                  const EffectiveContext &EC,
                                  AccessTarget &entity) {
assert(entity.isMemberAccess())((void)0);
NamedDecl *D = entity.getTargetDecl();

if (D->getAccess() == AS_protected &&
    TryDiagnoseProtectedAccess(S, EC, entity))
  return;

// Find an original declaration.
while (D->isOutOfLine()) {
  NamedDecl *PrevDecl = nullptr;
  if (VarDecl *VD = dyn_cast<VarDecl>(D))
    PrevDecl = VD->getPreviousDecl();
  else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
    PrevDecl = FD->getPreviousDecl();
  else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(D))
    PrevDecl = TND->getPreviousDecl();
  else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
    if (isa<RecordDecl>(D) && cast<RecordDecl>(D)->isInjectedClassName())
      break;
    PrevDecl = TD->getPreviousDecl();
  }
  if (!PrevDecl) break;
  D = PrevDecl;
}

CXXRecordDecl *DeclaringClass = FindDeclaringClass(D);
Decl *ImmediateChild;
if (D->getDeclContext() == DeclaringClass)
  ImmediateChild = D;
else {
  DeclContext *DC = D->getDeclContext();
  while (DC->getParent() != DeclaringClass)
    DC = DC->getParent();
  ImmediateChild = cast<Decl>(DC);
}

// Check whether there's an AccessSpecDecl preceding this in the
// chain of the DeclContext.
bool isImplicit = true;
for (const auto *I : DeclaringClass->decls()) {
  if (I == ImmediateChild) break;
  if (isa<AccessSpecDecl>(I)) {
    isImplicit = false;
    break;
  }
}

S.Diag(D->getLocation(), diag::note_access_natural)
  << (unsigned) (D->getAccess() == AS_protected)
  << isImplicit;
1159}

1161/// Diagnose the path which caused the given declaration or base class
1162/// to become inaccessible.
1163static void DiagnoseAccessPath(Sema &S,
                             const EffectiveContext &EC,
                             AccessTarget &entity) {
// Save the instance context to preserve invariants.
AccessTarget::SavedInstanceContext _ = entity.saveInstanceContext();

// This basically repeats the main algorithm but keeps some more
// information.

// The natural access so far.
AccessSpecifier accessSoFar = AS_public;

// Check whether we have special rights to the declaring class.
if (entity.isMemberAccess()) {
18
←
Calling 'AccessedEntity::isMemberAccess'→
20
←
Returning from 'AccessedEntity::isMemberAccess'→
21
←
Taking false branch→
  NamedDecl *D = entity.getTargetDecl();
  accessSoFar = D->getAccess();
  const CXXRecordDecl *declaringClass = entity.getDeclaringClass();

  switch (HasAccess(S, EC, declaringClass, accessSoFar, entity)) {
  // If the declaration is accessible when named in its declaring
  // class, then we must be constrained by the path.
  case AR_accessible:
    accessSoFar = AS_public;
    entity.suppressInstanceContext();
    break;

  case AR_inaccessible:
    if (accessSoFar == AS_private ||
        declaringClass == entity.getEffectiveNamingClass())
      return diagnoseBadDirectAccess(S, EC, entity);
    break;

  case AR_dependent:
    llvm_unreachable("cannot diagnose dependent access")__builtin_unreachable();
  }
}

CXXBasePaths paths;
CXXBasePath &path = *FindBestPath(S, EC, entity, accessSoFar, paths);
assert(path.Access != AS_public)((void)0);

CXXBasePath::iterator i = path.end(), e = path.begin();
CXXBasePath::iterator constrainingBase = i;
while (i != e) {
22
←
Assuming 'i' is not equal to 'e'→
23
←
Loop condition is true.  Entering loop body→
30
←
Loop condition is false. Execution continues on line 1246→
  --i;

  assert(accessSoFar != AS_none && accessSoFar != AS_private)((void)0);

  // Is the entity accessible when named in the deriving class, as
  // modified by the base specifier?
  const CXXRecordDecl *derivingClass = i->Class->getCanonicalDecl();
  const CXXBaseSpecifier *base = i->Base;

  // If the access to this base is worse than the access we have to
  // the declaration, remember it.
  AccessSpecifier baseAccess = base->getAccessSpecifier();
  if (baseAccess > accessSoFar) {
24
←
Assuming 'baseAccess' is <= 'accessSoFar'→
25
←
Taking false branch→
    constrainingBase = i;
    accessSoFar = baseAccess;
  }

  switch (HasAccess(S, EC, derivingClass, accessSoFar, entity)) {
26
←
Control jumps to 'case AR_accessible:'  at line 1226→
  case AR_inaccessible: break;
  case AR_accessible:
    accessSoFar = AS_public;
    entity.suppressInstanceContext();
    constrainingBase = nullptr;
27
←
Null pointer value stored to 'constrainingBase'→
    break;
28
←
 Execution continues on line 1237→
  case AR_dependent:
    llvm_unreachable("cannot diagnose dependent access")__builtin_unreachable();
  }

  // If this was private inheritance, but we don't have access to
  // the deriving class, we're done.
  if (accessSoFar28.1
'accessSoFar' is not equal to AS_private
1
'accessSoFar' is not equal to AS_private
 == AS_private) {
29
←
Taking false branch→
    assert(baseAccess == AS_private)((void)0);
    assert(constrainingBase == i)((void)0);
    break;
  }
}

// If we don't have a constraining base, the access failure must be
// due to the original declaration.
if (constrainingBase == path.end())
31
←
Assuming the condition is false→
32
←
Taking false branch→
  return diagnoseBadDirectAccess(S, EC, entity);

// We're constrained by inheritance, but we want to say
// "declared private here" if we're diagnosing a hierarchy
// conversion and this is the final step.
unsigned diagnostic;
if (entity.isMemberAccess() ||
33
←
Assuming the condition is true→
    constrainingBase + 1 != path.end()) {
  diagnostic = diag::note_access_constrained_by_path;
} else {
  diagnostic = diag::note_access_natural;
}

const CXXBaseSpecifier *base = constrainingBase->Base;
34
←
Access to field 'Base' results in a dereference of a null pointer (loaded from variable 'constrainingBase')

S.Diag(base->getSourceRange().getBegin(), diagnostic)
  << base->getSourceRange()
  << (base->getAccessSpecifier() == AS_protected)
  << (base->getAccessSpecifierAsWritten() == AS_none);

if (entity.isMemberAccess())
  S.Diag(entity.getTargetDecl()->getLocation(),
         diag::note_member_declared_at);
1270}

1272static void DiagnoseBadAccess(Sema &S, SourceLocation Loc,
                            const EffectiveContext &EC,
                            AccessTarget &Entity) {
const CXXRecordDecl *NamingClass = Entity.getNamingClass();
const CXXRecordDecl *DeclaringClass = Entity.getDeclaringClass();
NamedDecl *D = (Entity.isMemberAccess() ? Entity.getTargetDecl() : nullptr);
13
←
Assuming the condition is false→
14
←
'?' condition is false→

S.Diag(Loc, Entity.getDiag())
  << (Entity.getAccess() == AS_protected)
15
←
Assuming the condition is false→
  << (D15.1
'D' is null
1
'D' is null
 ? D->getDeclName() : DeclarationName())
16
←
'?' condition is false→
  << S.Context.getTypeDeclType(NamingClass)
  << S.Context.getTypeDeclType(DeclaringClass);
DiagnoseAccessPath(S, EC, Entity);
17
←
Calling 'DiagnoseAccessPath'→
1285}

1287/// MSVC has a bug where if during an using declaration name lookup,
1288/// the declaration found is unaccessible (private) and that declaration
1289/// was bring into scope via another using declaration whose target
1290/// declaration is accessible (public) then no error is generated.
1291/// Example:
1292///   class A {
1293///   public:
1294///     int f();
1295///   };
1296///   class B : public A {
1297///   private:
1298///     using A::f;
1299///   };
1300///   class C : public B {
1301///   private:
1302///     using B::f;
1303///   };
1304///
1305/// Here, B::f is private so this should fail in Standard C++, but
1306/// because B::f refers to A::f which is public MSVC accepts it.
1307static bool IsMicrosoftUsingDeclarationAccessBug(Sema& S,
                                               SourceLocation AccessLoc,
                                               AccessTarget &Entity) {
if (UsingShadowDecl *Shadow =
        dyn_cast<UsingShadowDecl>(Entity.getTargetDecl()))
  if (UsingDecl *UD = dyn_cast<UsingDecl>(Shadow->getIntroducer())) {
    const NamedDecl *OrigDecl = Entity.getTargetDecl()->getUnderlyingDecl();
    if (Entity.getTargetDecl()->getAccess() == AS_private &&
        (OrigDecl->getAccess() == AS_public ||
         OrigDecl->getAccess() == AS_protected)) {
      S.Diag(AccessLoc, diag::ext_ms_using_declaration_inaccessible)
          << UD->getQualifiedNameAsString()
          << OrigDecl->getQualifiedNameAsString();
      return true;
    }
  }
return false;
1324}

1326/// Determines whether the accessed entity is accessible.  Public members
1327/// have been weeded out by this point.
1328static AccessResult IsAccessible(Sema &S,
                               const EffectiveContext &EC,
                               AccessTarget &Entity) {
// Determine the actual naming class.
const CXXRecordDecl *NamingClass = Entity.getEffectiveNamingClass();

AccessSpecifier UnprivilegedAccess = Entity.getAccess();
assert(UnprivilegedAccess != AS_public && "public access not weeded out")((void)0);

// Before we try to recalculate access paths, try to white-list
// accesses which just trade in on the final step, i.e. accesses
// which don't require [M4] or [B4]. These are by far the most
// common forms of privileged access.
if (UnprivilegedAccess != AS_none) {
  switch (HasAccess(S, EC, NamingClass, UnprivilegedAccess, Entity)) {
  case AR_dependent:
    // This is actually an interesting policy decision.  We don't
    // *have* to delay immediately here: we can do the full access
    // calculation in the hope that friendship on some intermediate
    // class will make the declaration accessible non-dependently.
    // But that's not cheap, and odds are very good (note: assertion
    // made without data) that the friend declaration will determine
    // access.
    return AR_dependent;

  case AR_accessible: return AR_accessible;
  case AR_inaccessible: break;
  }
}

AccessTarget::SavedInstanceContext _ = Entity.saveInstanceContext();

// We lower member accesses to base accesses by pretending that the
// member is a base class of its declaring class.
AccessSpecifier FinalAccess;

if (Entity.isMemberAccess()) {
  // Determine if the declaration is accessible from EC when named
  // in its declaring class.
  NamedDecl *Target = Entity.getTargetDecl();
  const CXXRecordDecl *DeclaringClass = Entity.getDeclaringClass();

  FinalAccess = Target->getAccess();
  switch (HasAccess(S, EC, DeclaringClass, FinalAccess, Entity)) {
  case AR_accessible:
    // Target is accessible at EC when named in its declaring class.
    // We can now hill-climb and simply check whether the declaring
    // class is accessible as a base of the naming class.  This is
    // equivalent to checking the access of a notional public
    // member with no instance context.
    FinalAccess = AS_public;
    Entity.suppressInstanceContext();
    break;
  case AR_inaccessible: break;
  case AR_dependent: return AR_dependent; // see above
  }

  if (DeclaringClass == NamingClass)
    return (FinalAccess == AS_public ? AR_accessible : AR_inaccessible);
} else {
  FinalAccess = AS_public;
}

assert(Entity.getDeclaringClass() != NamingClass)((void)0);

// Append the declaration's access if applicable.
CXXBasePaths Paths;
CXXBasePath *Path = FindBestPath(S, EC, Entity, FinalAccess, Paths);
if (!Path)
  return AR_dependent;

assert(Path->Access <= UnprivilegedAccess &&((void)0)
       "access along best path worse than direct?")((void)0);
if (Path->Access == AS_public)
  return AR_accessible;
return AR_inaccessible;
1404}

1406static void DelayDependentAccess(Sema &S,
                               const EffectiveContext &EC,
                               SourceLocation Loc,
                               const AccessTarget &Entity) {
assert(EC.isDependent() && "delaying non-dependent access")((void)0);
DeclContext *DC = EC.getInnerContext();
assert(DC->isDependentContext() && "delaying non-dependent access")((void)0);
DependentDiagnostic::Create(S.Context, DC, DependentDiagnostic::Access,
                            Loc,
                            Entity.isMemberAccess(),
                            Entity.getAccess(),
                            Entity.getTargetDecl(),
                            Entity.getNamingClass(),
                            Entity.getBaseObjectType(),
                            Entity.getDiag());
1421}

1423/// Checks access to an entity from the given effective context.
1424static AccessResult CheckEffectiveAccess(Sema &S,
                                       const EffectiveContext &EC,
                                       SourceLocation Loc,
                                       AccessTarget &Entity) {
assert(Entity.getAccess() != AS_public && "called for public access!")((void)0);

switch (IsAccessible(S, EC, Entity)) {
9
←
Control jumps to 'case AR_inaccessible:'  at line 1435→
case AR_dependent:
  DelayDependentAccess(S, EC, Loc, Entity);
  return AR_dependent;

case AR_inaccessible:
  if (S.getLangOpts().MSVCCompat &&
10
←
Assuming field 'MSVCCompat' is 0→
      IsMicrosoftUsingDeclarationAccessBug(S, Loc, Entity))
    return AR_accessible;
  if (!Entity.isQuiet())
11
←
Taking true branch→
    DiagnoseBadAccess(S, Loc, EC, Entity);
12
←
Calling 'DiagnoseBadAccess'→
  return AR_inaccessible;

case AR_accessible:
  return AR_accessible;
}

// silence unnecessary warning
llvm_unreachable("invalid access result")__builtin_unreachable();
1449}

1451static Sema::AccessResult CheckAccess(Sema &S, SourceLocation Loc,
                                    AccessTarget &Entity) {
// If the access path is public, it's accessible everywhere.
if (Entity.getAccess() == AS_public)
6
←
Taking false branch→
  return Sema::AR_accessible;

// If we're currently parsing a declaration, we may need to delay
// access control checking, because our effective context might be
// different based on what the declaration comes out as.
//
// For example, we might be parsing a declaration with a scope
// specifier, like this:
//   A::private_type A::foo() { ... }
//
// Or we might be parsing something that will turn out to be a friend:
//   void foo(A::private_type);
//   void B::foo(A::private_type);
if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {
7
←
Taking false branch→
  S.DelayedDiagnostics.add(DelayedDiagnostic::makeAccess(Loc, Entity));
  return Sema::AR_delayed;
}

EffectiveContext EC(S.CurContext);
switch (CheckEffectiveAccess(S, EC, Loc, Entity)) {
8
←
Calling 'CheckEffectiveAccess'→
case AR_accessible: return Sema::AR_accessible;
case AR_inaccessible: return Sema::AR_inaccessible;
case AR_dependent: return Sema::AR_dependent;
}
llvm_unreachable("invalid access result")__builtin_unreachable();
1480}

1482void Sema::HandleDelayedAccessCheck(DelayedDiagnostic &DD, Decl *D) {
// Access control for names used in the declarations of functions
// and function templates should normally be evaluated in the context
// of the declaration, just in case it's a friend of something.
// However, this does not apply to local extern declarations.

DeclContext *DC = D->getDeclContext();
if (D->isLocalExternDecl()) {
  DC = D->getLexicalDeclContext();
} else if (FunctionDecl *FN = dyn_cast<FunctionDecl>(D)) {
  DC = FN;
} else if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) {
  if (isa<DeclContext>(TD->getTemplatedDecl()))
    DC = cast<DeclContext>(TD->getTemplatedDecl());
}

EffectiveContext EC(DC);

AccessTarget Target(DD.getAccessData());

if (CheckEffectiveAccess(*this, EC, DD.Loc, Target) == ::AR_inaccessible)
  DD.Triggered = true;
1504}

1506void Sema::HandleDependentAccessCheck(const DependentDiagnostic &DD,
                      const MultiLevelTemplateArgumentList &TemplateArgs) {
SourceLocation Loc = DD.getAccessLoc();
AccessSpecifier Access = DD.getAccess();

Decl *NamingD = FindInstantiatedDecl(Loc, DD.getAccessNamingClass(),
                                     TemplateArgs);
if (!NamingD) return;
Decl *TargetD = FindInstantiatedDecl(Loc, DD.getAccessTarget(),
                                     TemplateArgs);
if (!TargetD) return;

if (DD.isAccessToMember()) {
  CXXRecordDecl *NamingClass = cast<CXXRecordDecl>(NamingD);
  NamedDecl *TargetDecl = cast<NamedDecl>(TargetD);
  QualType BaseObjectType = DD.getAccessBaseObjectType();
  if (!BaseObjectType.isNull()) {
    BaseObjectType = SubstType(BaseObjectType, TemplateArgs, Loc,
                               DeclarationName());
    if (BaseObjectType.isNull()) return;
  }

  AccessTarget Entity(Context,
                      AccessTarget::Member,
                      NamingClass,
                      DeclAccessPair::make(TargetDecl, Access),
                      BaseObjectType);
  Entity.setDiag(DD.getDiagnostic());
  CheckAccess(*this, Loc, Entity);
} else {
  AccessTarget Entity(Context,
                      AccessTarget::Base,
                      cast<CXXRecordDecl>(TargetD),
                      cast<CXXRecordDecl>(NamingD),
                      Access);
  Entity.setDiag(DD.getDiagnostic());
  CheckAccess(*this, Loc, Entity);
}
1544}

1546Sema::AccessResult Sema::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,
                                                   DeclAccessPair Found) {
if (!getLangOpts().AccessControl ||
    !E->getNamingClass() ||
    Found.getAccess() == AS_public)
  return AR_accessible;

AccessTarget Entity(Context, AccessTarget::Member, E->getNamingClass(),
                    Found, QualType());
Entity.setDiag(diag::err_access) << E->getSourceRange();

return CheckAccess(*this, E->getNameLoc(), Entity);
1558}

1560/// Perform access-control checking on a previously-unresolved member
1561/// access which has now been resolved to a member.
1562Sema::AccessResult Sema::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,
                                                   DeclAccessPair Found) {
if (!getLangOpts().AccessControl ||
    Found.getAccess() == AS_public)
  return AR_accessible;

QualType BaseType = E->getBaseType();
if (E->isArrow())
  BaseType = BaseType->castAs<PointerType>()->getPointeeType();

AccessTarget Entity(Context, AccessTarget::Member, E->getNamingClass(),
                    Found, BaseType);
Entity.setDiag(diag::err_access) << E->getSourceRange();

return CheckAccess(*this, E->getMemberLoc(), Entity);
1577}

1579/// Is the given member accessible for the purposes of deciding whether to
1580/// define a special member function as deleted?
1581bool Sema::isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
                                       DeclAccessPair Found,
                                       QualType ObjectType,
                                       SourceLocation Loc,
                                       const PartialDiagnostic &Diag) {
// Fast path.
if (Found.getAccess() == AS_public || !getLangOpts().AccessControl)
  return true;

AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found,
                    ObjectType);

// Suppress diagnostics.
Entity.setDiag(Diag);

switch (CheckAccess(*this, Loc, Entity)) {
case AR_accessible: return true;
case AR_inaccessible: return false;
case AR_dependent: llvm_unreachable("dependent for =delete computation")__builtin_unreachable();
case AR_delayed: llvm_unreachable("cannot delay =delete computation")__builtin_unreachable();
}
llvm_unreachable("bad access result")__builtin_unreachable();
1603}

1605Sema::AccessResult Sema::CheckDestructorAccess(SourceLocation Loc,
                                             CXXDestructorDecl *Dtor,
                                             const PartialDiagnostic &PDiag,
                                             QualType ObjectTy) {
if (!getLangOpts().AccessControl)
  return AR_accessible;

// There's never a path involved when checking implicit destructor access.
AccessSpecifier Access = Dtor->getAccess();
if (Access == AS_public)
  return AR_accessible;

CXXRecordDecl *NamingClass = Dtor->getParent();
if (ObjectTy.isNull()) ObjectTy = Context.getTypeDeclType(NamingClass);

AccessTarget Entity(Context, AccessTarget::Member, NamingClass,
                    DeclAccessPair::make(Dtor, Access),
                    ObjectTy);
Entity.setDiag(PDiag); // TODO: avoid copy

return CheckAccess(*this, Loc, Entity);
1626}

1628/// Checks access to a constructor.
1629Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc,
                                              CXXConstructorDecl *Constructor,
                                              DeclAccessPair Found,
                                              const InitializedEntity &Entity,
                                              bool IsCopyBindingRefToTemp) {
if (!getLangOpts().AccessControl || Found.getAccess() == AS_public)
  return AR_accessible;

PartialDiagnostic PD(PDiag());
switch (Entity.getKind()) {
default:
  PD = PDiag(IsCopyBindingRefToTemp
               ? diag::ext_rvalue_to_reference_access_ctor
               : diag::err_access_ctor);

  break;

case InitializedEntity::EK_Base:
  PD = PDiag(diag::err_access_base_ctor);
  PD << Entity.isInheritedVirtualBase()
     << Entity.getBaseSpecifier()->getType() << getSpecialMember(Constructor);
  break;

case InitializedEntity::EK_Member: {
  const FieldDecl *Field = cast<FieldDecl>(Entity.getDecl());
  PD = PDiag(diag::err_access_field_ctor);
  PD << Field->getType() << getSpecialMember(Constructor);
  break;
}

case InitializedEntity::EK_LambdaCapture: {
  StringRef VarName = Entity.getCapturedVarName();
  PD = PDiag(diag::err_access_lambda_capture);
  PD << VarName << Entity.getType() << getSpecialMember(Constructor);
  break;
}

}

return CheckConstructorAccess(UseLoc, Constructor, Found, Entity, PD);
1669}

1671/// Checks access to a constructor.
1672Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc,
                                              CXXConstructorDecl *Constructor,
                                              DeclAccessPair Found,
                                              const InitializedEntity &Entity,
                                              const PartialDiagnostic &PD) {
if (!getLangOpts().AccessControl ||
    Found.getAccess() == AS_public)
  return AR_accessible;

CXXRecordDecl *NamingClass = Constructor->getParent();

// Initializing a base sub-object is an instance method call on an
// object of the derived class.  Otherwise, we have an instance method
// call on an object of the constructed type.
//
// FIXME: If we have a parent, we're initializing the base class subobject
// in aggregate initialization. It's not clear whether the object class
// should be the base class or the derived class in that case.
CXXRecordDecl *ObjectClass;
if ((Entity.getKind() == InitializedEntity::EK_Base ||
     Entity.getKind() == InitializedEntity::EK_Delegating) &&
    !Entity.getParent()) {
  ObjectClass = cast<CXXConstructorDecl>(CurContext)->getParent();
} else if (auto *Shadow =
               dyn_cast<ConstructorUsingShadowDecl>(Found.getDecl())) {
  // If we're using an inheriting constructor to construct an object,
  // the object class is the derived class, not the base class.
  ObjectClass = Shadow->getParent();
} else {
  ObjectClass = NamingClass;
}

AccessTarget AccessEntity(
    Context, AccessTarget::Member, NamingClass,
    DeclAccessPair::make(Constructor, Found.getAccess()),
    Context.getTypeDeclType(ObjectClass));
AccessEntity.setDiag(PD);

return CheckAccess(*this, UseLoc, AccessEntity);
1711}

1713/// Checks access to an overloaded operator new or delete.
1714Sema::AccessResult Sema::CheckAllocationAccess(SourceLocation OpLoc,
                                             SourceRange PlacementRange,
                                             CXXRecordDecl *NamingClass,
                                             DeclAccessPair Found,
                                             bool Diagnose) {
if (!getLangOpts().AccessControl ||
    !NamingClass ||
    Found.getAccess() == AS_public)
  return AR_accessible;

AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found,
                    QualType());
if (Diagnose)
  Entity.setDiag(diag::err_access)
    << PlacementRange;

return CheckAccess(*this, OpLoc, Entity);
1731}

1733/// Checks access to a member.
1734Sema::AccessResult Sema::CheckMemberAccess(SourceLocation UseLoc,
                                         CXXRecordDecl *NamingClass,
                                         DeclAccessPair Found) {
if (!getLangOpts().AccessControl ||
    !NamingClass ||
    Found.getAccess() == AS_public)
  return AR_accessible;

AccessTarget Entity(Context, AccessTarget::Member, NamingClass,
                    Found, QualType());

return CheckAccess(*this, UseLoc, Entity);
1746}

1748/// Checks implicit access to a member in a structured binding.
1749Sema::AccessResult
1750Sema::CheckStructuredBindingMemberAccess(SourceLocation UseLoc,
                                       CXXRecordDecl *DecomposedClass,
                                       DeclAccessPair Field) {
if (!getLangOpts().AccessControl ||
    Field.getAccess() == AS_public)
  return AR_accessible;

AccessTarget Entity(Context, AccessTarget::Member, DecomposedClass, Field,
                    Context.getRecordType(DecomposedClass));
Entity.setDiag(diag::err_decomp_decl_inaccessible_field);

return CheckAccess(*this, UseLoc, Entity);
1762}

1764/// Checks access to an overloaded member operator, including
1765/// conversion operators.
1766Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc,
                                                 Expr *ObjectExpr,
                                                 Expr *ArgExpr,
                                                 DeclAccessPair Found) {
if (!getLangOpts().AccessControl ||
    Found.getAccess() == AS_public)
  return AR_accessible;

const RecordType *RT = ObjectExpr->getType()->castAs<RecordType>();
CXXRecordDecl *NamingClass = cast<CXXRecordDecl>(RT->getDecl());

AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found,
                    ObjectExpr->getType());
Entity.setDiag(diag::err_access)
  << ObjectExpr->getSourceRange()
  << (ArgExpr ? ArgExpr->getSourceRange() : SourceRange());

return CheckAccess(*this, OpLoc, Entity);
1784}

1786/// Checks access to the target of a friend declaration.
1787Sema::AccessResult Sema::CheckFriendAccess(NamedDecl *target) {
assert(isa<CXXMethodDecl>(target->getAsFunction()))((void)0);

// Friendship lookup is a redeclaration lookup, so there's never an
// inheritance path modifying access.
AccessSpecifier access = target->getAccess();

if (!getLangOpts().AccessControl || access == AS_public)
  return AR_accessible;

CXXMethodDecl *method = cast<CXXMethodDecl>(target->getAsFunction());

AccessTarget entity(Context, AccessTarget::Member,
                    cast<CXXRecordDecl>(target->getDeclContext()),
                    DeclAccessPair::make(target, access),
                    /*no instance context*/ QualType());
entity.setDiag(diag::err_access_friend_function)
    << (method->getQualifier() ? method->getQualifierLoc().getSourceRange()
                               : method->getNameInfo().getSourceRange());

// We need to bypass delayed-diagnostics because we might be called
// while the ParsingDeclarator is active.
EffectiveContext EC(CurContext);
switch (CheckEffectiveAccess(*this, EC, target->getLocation(), entity)) {
case ::AR_accessible: return Sema::AR_accessible;
case ::AR_inaccessible: return Sema::AR_inaccessible;
case ::AR_dependent: return Sema::AR_dependent;
}
llvm_unreachable("invalid access result")__builtin_unreachable();
1816}

1818Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr,
                                                  DeclAccessPair Found) {
if (!getLangOpts().AccessControl ||
1
Assuming field 'AccessControl' is not equal to 0→
4
←
Taking false branch→
    Found.getAccess() == AS_none ||
2
←
Assuming the condition is false→
    Found.getAccess() == AS_public)
3
←
Assuming the condition is false→
  return AR_accessible;

OverloadExpr *Ovl = OverloadExpr::find(OvlExpr).Expression;
CXXRecordDecl *NamingClass = Ovl->getNamingClass();

AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found,
                    /*no instance context*/ QualType());
Entity.setDiag(diag::err_access)
  << Ovl->getSourceRange();

return CheckAccess(*this, Ovl->getNameLoc(), Entity);
5
←
Calling 'CheckAccess'→
1834}

1836/// Checks access for a hierarchy conversion.
1837///
1838/// \param ForceCheck true if this check should be performed even if access
1839///     control is disabled;  some things rely on this for semantics
1840/// \param ForceUnprivileged true if this check should proceed as if the
1841///     context had no special privileges
1842Sema::AccessResult Sema::CheckBaseClassAccess(SourceLocation AccessLoc,
                                            QualType Base,
                                            QualType Derived,
                                            const CXXBasePath &Path,
                                            unsigned DiagID,
                                            bool ForceCheck,
                                            bool ForceUnprivileged) {
if (!ForceCheck && !getLangOpts().AccessControl)
  return AR_accessible;

if (Path.Access == AS_public)
  return AR_accessible;

CXXRecordDecl *BaseD, *DerivedD;
BaseD = cast<CXXRecordDecl>(Base->castAs<RecordType>()->getDecl());
DerivedD = cast<CXXRecordDecl>(Derived->castAs<RecordType>()->getDecl());

AccessTarget Entity(Context, AccessTarget::Base, BaseD, DerivedD,
                    Path.Access);
if (DiagID)
  Entity.setDiag(DiagID) << Derived << Base;

if (ForceUnprivileged) {
  switch (CheckEffectiveAccess(*this, EffectiveContext(),
                               AccessLoc, Entity)) {
  case ::AR_accessible: return Sema::AR_accessible;
  case ::AR_inaccessible: return Sema::AR_inaccessible;
  case ::AR_dependent: return Sema::AR_dependent;
  }
  llvm_unreachable("unexpected result from CheckEffectiveAccess")__builtin_unreachable();
}
return CheckAccess(*this, AccessLoc, Entity);
1874}

1876/// Checks access to all the declarations in the given result set.
1877void Sema::CheckLookupAccess(const LookupResult &R) {
assert(getLangOpts().AccessControl((void)0)
       && "performing access check without access control")((void)0);
assert(R.getNamingClass() && "performing access check without naming class")((void)0);

for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
  if (I.getAccess() != AS_public) {
    AccessTarget Entity(Context, AccessedEntity::Member,
                        R.getNamingClass(), I.getPair(),
                        R.getBaseObjectType());
    Entity.setDiag(diag::err_access);
    CheckAccess(*this, R.getNameLoc(), Entity);
  }
}
1891}

1893/// Checks access to Target from the given class. The check will take access
1894/// specifiers into account, but no member access expressions and such.
1895///
1896/// \param Target the declaration to check if it can be accessed
1897/// \param NamingClass the class in which the lookup was started.
1898/// \param BaseType type of the left side of member access expression.
1899///        \p BaseType and \p NamingClass are used for C++ access control.
1900///        Depending on the lookup case, they should be set to the following:
1901///        - lhs.target (member access without a qualifier):
1902///          \p BaseType and \p NamingClass are both the type of 'lhs'.
1903///        - lhs.X::target (member access with a qualifier):
1904///          BaseType is the type of 'lhs', NamingClass is 'X'
1905///        - X::target (qualified lookup without member access):
1906///          BaseType is null, NamingClass is 'X'.
1907///        - target (unqualified lookup).
1908///          BaseType is null, NamingClass is the parent class of 'target'.
1909/// \return true if the Target is accessible from the Class, false otherwise.
1910bool Sema::IsSimplyAccessible(NamedDecl *Target, CXXRecordDecl *NamingClass,
                            QualType BaseType) {
// Perform the C++ accessibility checks first.
if (Target->isCXXClassMember() && NamingClass) {
  if (!getLangOpts().CPlusPlus)
    return false;
  // The unprivileged access is AS_none as we don't know how the member was
  // accessed, which is described by the access in DeclAccessPair.
  // `IsAccessible` will examine the actual access of Target (i.e.
  // Decl->getAccess()) when calculating the access.
  AccessTarget Entity(Context, AccessedEntity::Member, NamingClass,
                      DeclAccessPair::make(Target, AS_none), BaseType);
  EffectiveContext EC(CurContext);
  return ::IsAccessible(*this, EC, Entity) != ::AR_inaccessible;
}

if (ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(Target)) {
  // @public and @package ivars are always accessible.
  if (Ivar->getCanonicalAccessControl() == ObjCIvarDecl::Public ||
      Ivar->getCanonicalAccessControl() == ObjCIvarDecl::Package)
    return true;

  // If we are inside a class or category implementation, determine the
  // interface we're in.
  ObjCInterfaceDecl *ClassOfMethodDecl = nullptr;
  if (ObjCMethodDecl *MD = getCurMethodDecl())
    ClassOfMethodDecl =  MD->getClassInterface();
  else if (FunctionDecl *FD = getCurFunctionDecl()) {
    if (ObjCImplDecl *Impl
          = dyn_cast<ObjCImplDecl>(FD->getLexicalDeclContext())) {
      if (ObjCImplementationDecl *IMPD
            = dyn_cast<ObjCImplementationDecl>(Impl))
        ClassOfMethodDecl = IMPD->getClassInterface();
      else if (ObjCCategoryImplDecl* CatImplClass
                 = dyn_cast<ObjCCategoryImplDecl>(Impl))
        ClassOfMethodDecl = CatImplClass->getClassInterface();
    }
  }

  // If we're not in an interface, this ivar is inaccessible.
  if (!ClassOfMethodDecl)
    return false;

  // If we're inside the same interface that owns the ivar, we're fine.
  if (declaresSameEntity(ClassOfMethodDecl, Ivar->getContainingInterface()))
    return true;

  // If the ivar is private, it's inaccessible.
  if (Ivar->getCanonicalAccessControl() == ObjCIvarDecl::Private)
    return false;

  return Ivar->getContainingInterface()->isSuperClassOf(ClassOfMethodDecl);
}

return true;
1965}

←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include/clang/Sema/DelayedDiagnostic.h

1//===- DelayedDiagnostic.h - Delayed declarator diagnostics -----*- 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/// \file
10/// Defines the classes clang::DelayedDiagnostic and
11/// clang::AccessedEntity.
12///
13/// DelayedDiangostic is used to record diagnostics that are being
14/// conditionally produced during declarator parsing.  Certain kinds of
15/// diagnostics -- notably deprecation and access control -- are suppressed
16/// based on semantic properties of the parsed declaration that aren't known
17/// until it is fully parsed.
18//
19//===----------------------------------------------------------------------===//

21#ifndef LLVM_CLANG_SEMA_DELAYEDDIAGNOSTIC_H
22#define LLVM_CLANG_SEMA_DELAYEDDIAGNOSTIC_H

24#include "clang/AST/DeclAccessPair.h"
25#include "clang/AST/DeclBase.h"
26#include "clang/AST/DeclCXX.h"
27#include "clang/AST/Type.h"
28#include "clang/Basic/LLVM.h"
29#include "clang/Basic/PartialDiagnostic.h"
30#include "clang/Basic/SourceLocation.h"
31#include "clang/Basic/Specifiers.h"
32#include "clang/Sema/Sema.h"
33#include "llvm/ADT/ArrayRef.h"
34#include "llvm/ADT/SmallVector.h"
35#include "llvm/ADT/StringRef.h"
36#include "llvm/Support/Casting.h"
37#include <cassert>
38#include <cstddef>
39#include <utility>

41namespace clang {

43class ObjCInterfaceDecl;
44class ObjCPropertyDecl;

46namespace sema {

48/// A declaration being accessed, together with information about how
49/// it was accessed.
50class AccessedEntity {
51public:
/// A member declaration found through lookup.  The target is the
/// member.
enum MemberNonce { Member };

/// A hierarchy (base-to-derived or derived-to-base) conversion.
/// The target is the base class.
enum BaseNonce { Base };

AccessedEntity(PartialDiagnostic::DiagStorageAllocator &Allocator,
               MemberNonce _, CXXRecordDecl *NamingClass,
               DeclAccessPair FoundDecl, QualType BaseObjectType)
    : Access(FoundDecl.getAccess()), IsMember(true),
      Target(FoundDecl.getDecl()), NamingClass(NamingClass),
      BaseObjectType(BaseObjectType), Diag(0, Allocator) {}

AccessedEntity(PartialDiagnostic::DiagStorageAllocator &Allocator,
               BaseNonce _, CXXRecordDecl *BaseClass,
               CXXRecordDecl *DerivedClass, AccessSpecifier Access)
    : Access(Access), IsMember(false), Target(BaseClass),
      NamingClass(DerivedClass), Diag(0, Allocator) {}

bool isMemberAccess() const { return IsMember; }
19
←
Returning zero, which participates in a condition later→

bool isQuiet() const { return Diag.getDiagID() == 0; }

AccessSpecifier getAccess() const { return AccessSpecifier(Access); }

// These apply to member decls...
NamedDecl *getTargetDecl() const { return Target; }
CXXRecordDecl *getNamingClass() const { return NamingClass; }

// ...and these apply to hierarchy conversions.
CXXRecordDecl *getBaseClass() const {
  assert(!IsMember)((void)0); return cast<CXXRecordDecl>(Target);
}
CXXRecordDecl *getDerivedClass() const { return NamingClass; }

/// Retrieves the base object type, important when accessing
/// an instance member.
QualType getBaseObjectType() const { return BaseObjectType; }

/// Sets a diagnostic to be performed.  The diagnostic is given
/// four (additional) arguments:
///   %0 - 0 if the entity was private, 1 if protected
///   %1 - the DeclarationName of the entity
///   %2 - the TypeDecl type of the naming class
///   %3 - the TypeDecl type of the declaring class
void setDiag(const PartialDiagnostic &PDiag) {
  assert(isQuiet() && "partial diagnostic already defined")((void)0);
  Diag = PDiag;
}
PartialDiagnostic &setDiag(unsigned DiagID) {
  assert(isQuiet() && "partial diagnostic already defined")((void)0);
  assert(DiagID && "creating null diagnostic")((void)0);
  Diag.Reset(DiagID);
  return Diag;
}
const PartialDiagnostic &getDiag() const {
  return Diag;
}

113private:
unsigned Access : 2;
unsigned IsMember : 1;
NamedDecl *Target;
CXXRecordDecl *NamingClass;
QualType BaseObjectType;
PartialDiagnostic Diag;
120};

122/// A diagnostic message which has been conditionally emitted pending
123/// the complete parsing of the current declaration.
124class DelayedDiagnostic {
125public:
enum DDKind : unsigned char { Availability, Access, ForbiddenType };

DDKind Kind;
bool Triggered;

SourceLocation Loc;

void Destroy();

static DelayedDiagnostic makeAvailability(AvailabilityResult AR,
                                          ArrayRef<SourceLocation> Locs,
                                          const NamedDecl *ReferringDecl,
                                          const NamedDecl *OffendingDecl,
                                          const ObjCInterfaceDecl *UnknownObjCClass,
                                          const ObjCPropertyDecl  *ObjCProperty,
                                          StringRef Msg,
                                          bool ObjCPropertyAccess);

static DelayedDiagnostic makeAccess(SourceLocation Loc,
                                    const AccessedEntity &Entity) {
  DelayedDiagnostic DD;
  DD.Kind = Access;
  DD.Triggered = false;
  DD.Loc = Loc;
  new (&DD.getAccessData()) AccessedEntity(Entity);
  return DD;
}

static DelayedDiagnostic makeForbiddenType(SourceLocation loc,
                                           unsigned diagnostic,
                                           QualType type,
                                           unsigned argument) {
  DelayedDiagnostic DD;
  DD.Kind = ForbiddenType;
  DD.Triggered = false;
  DD.Loc = loc;
  DD.ForbiddenTypeData.Diagnostic = diagnostic;
  DD.ForbiddenTypeData.OperandType = type.getAsOpaquePtr();
  DD.ForbiddenTypeData.Argument = argument;
  return DD;
}

AccessedEntity &getAccessData() {
  assert(Kind == Access && "Not an access diagnostic.")((void)0);
  return *reinterpret_cast<AccessedEntity*>(AccessData);
}
const AccessedEntity &getAccessData() const {
  assert(Kind == Access && "Not an access diagnostic.")((void)0);
  return *reinterpret_cast<const AccessedEntity*>(AccessData);
}

const NamedDecl *getAvailabilityReferringDecl() const {
  assert(Kind == Availability && "Not an availability diagnostic.")((void)0);
  return AvailabilityData.ReferringDecl;
}

const NamedDecl *getAvailabilityOffendingDecl() const {
  return AvailabilityData.OffendingDecl;
}

StringRef getAvailabilityMessage() const {
  assert(Kind == Availability && "Not an availability diagnostic.")((void)0);
  return StringRef(AvailabilityData.Message, AvailabilityData.MessageLen);
}

ArrayRef<SourceLocation> getAvailabilitySelectorLocs() const {
  assert(Kind == Availability && "Not an availability diagnostic.")((void)0);
  return llvm::makeArrayRef(AvailabilityData.SelectorLocs,
                            AvailabilityData.NumSelectorLocs);
}

AvailabilityResult getAvailabilityResult() const {
  assert(Kind == Availability && "Not an availability diagnostic.")((void)0);
  return AvailabilityData.AR;
}

/// The diagnostic ID to emit.  Used like so:
///   Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
///     << diag.getForbiddenTypeOperand()
///     << diag.getForbiddenTypeArgument();
unsigned getForbiddenTypeDiagnostic() const {
  assert(Kind == ForbiddenType && "not a forbidden-type diagnostic")((void)0);
  return ForbiddenTypeData.Diagnostic;
}

unsigned getForbiddenTypeArgument() const {
  assert(Kind == ForbiddenType && "not a forbidden-type diagnostic")((void)0);
  return ForbiddenTypeData.Argument;
}

QualType getForbiddenTypeOperand() const {
  assert(Kind == ForbiddenType && "not a forbidden-type diagnostic")((void)0);
  return QualType::getFromOpaquePtr(ForbiddenTypeData.OperandType);
}

const ObjCInterfaceDecl *getUnknownObjCClass() const {
  return AvailabilityData.UnknownObjCClass;
}

const ObjCPropertyDecl *getObjCProperty() const {
  return AvailabilityData.ObjCProperty;
}

bool getObjCPropertyAccess() const {
  return AvailabilityData.ObjCPropertyAccess;
}

233private:
struct AD {
  const NamedDecl *ReferringDecl;
  const NamedDecl *OffendingDecl;
  const ObjCInterfaceDecl *UnknownObjCClass;
  const ObjCPropertyDecl  *ObjCProperty;
  const char *Message;
  size_t MessageLen;
  SourceLocation *SelectorLocs;
  size_t NumSelectorLocs;
  AvailabilityResult AR;
  bool ObjCPropertyAccess;
};

struct FTD {
  unsigned Diagnostic;
  unsigned Argument;
  void *OperandType;
};

union {
  struct AD AvailabilityData;
  struct FTD ForbiddenTypeData;

  /// Access control.
  char AccessData[sizeof(AccessedEntity)];
};
260};

262/// A collection of diagnostics which were delayed.
263class DelayedDiagnosticPool {
const DelayedDiagnosticPool *Parent;
SmallVector<DelayedDiagnostic, 4> Diagnostics;

267public:
DelayedDiagnosticPool(const DelayedDiagnosticPool *parent) : Parent(parent) {}

DelayedDiagnosticPool(const DelayedDiagnosticPool &) = delete;
DelayedDiagnosticPool &operator=(const DelayedDiagnosticPool &) = delete;

DelayedDiagnosticPool(DelayedDiagnosticPool &&Other)
    : Parent(Other.Parent), Diagnostics(std::move(Other.Diagnostics)) {
  Other.Diagnostics.clear();
}

DelayedDiagnosticPool &operator=(DelayedDiagnosticPool &&Other) {
  Parent = Other.Parent;
  Diagnostics = std::move(Other.Diagnostics);
  Other.Diagnostics.clear();
  return *this;
}

~DelayedDiagnosticPool() {
  for (SmallVectorImpl<DelayedDiagnostic>::iterator
         i = Diagnostics.begin(), e = Diagnostics.end(); i != e; ++i)
    i->Destroy();
}

const DelayedDiagnosticPool *getParent() const { return Parent; }

/// Does this pool, or any of its ancestors, contain any diagnostics?
bool empty() const {
  return (Diagnostics.empty() && (!Parent || Parent->empty()));
}

/// Add a diagnostic to this pool.
void add(const DelayedDiagnostic &diag) {
  Diagnostics.push_back(diag);
}

/// Steal the diagnostics from the given pool.
void steal(DelayedDiagnosticPool &pool) {
  if (pool.Diagnostics.empty()) return;

  if (Diagnostics.empty()) {
    Diagnostics = std::move(pool.Diagnostics);
  } else {
    Diagnostics.append(pool.pool_begin(), pool.pool_end());
  }
  pool.Diagnostics.clear();
}

using pool_iterator = SmallVectorImpl<DelayedDiagnostic>::const_iterator;

pool_iterator pool_begin() const { return Diagnostics.begin(); }
pool_iterator pool_end() const { return Diagnostics.end(); }
bool pool_empty() const { return Diagnostics.empty(); }
320};

322} // namespace clang

324/// Add a diagnostic to the current delay pool.
325inline void Sema::DelayedDiagnostics::add(const sema::DelayedDiagnostic &diag) {
assert(shouldDelayDiagnostics() && "trying to delay without pool")((void)0);
CurPool->add(diag);
328}

330} // namespace clang

332#endif // LLVM_CLANG_SEMA_DELAYEDDIAGNOSTIC_H