SemaAccess.cpp revision b320e0c322fb71d6235ebca9ec22940a97bdcdc7 
1//===---- SemaAccess.cpp - C++ Access Control -------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file provides Sema routines for C++ access control semantics.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Sema/SemaInternal.h"
15#include "clang/Sema/DelayedDiagnostic.h"
16#include "clang/Sema/Initialization.h"
17#include "clang/Sema/Lookup.h"
18#include "clang/AST/ASTContext.h"
19#include "clang/AST/CXXInheritance.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclFriend.h"
22#include "clang/AST/DependentDiagnostic.h"
23#include "clang/AST/ExprCXX.h"
24
25using namespace clang;
26using namespace sema;
27
28/// A copy of Sema's enum without AR_delayed.
29enum AccessResult {
30  AR_accessible,
31  AR_inaccessible,
32  AR_dependent
33};
34
35/// SetMemberAccessSpecifier - Set the access specifier of a member.
36/// Returns true on error (when the previous member decl access specifier
37/// is different from the new member decl access specifier).
38bool Sema::SetMemberAccessSpecifier(NamedDecl *MemberDecl,
39                                    NamedDecl *PrevMemberDecl,
40                                    AccessSpecifier LexicalAS) {
41  if (!PrevMemberDecl) {
42    // Use the lexical access specifier.
43    MemberDecl->setAccess(LexicalAS);
44    return false;
45  }
46
47  // C++ [class.access.spec]p3: When a member is redeclared its access
48  // specifier must be same as its initial declaration.
49  if (LexicalAS != AS_none && LexicalAS != PrevMemberDecl->getAccess()) {
50    Diag(MemberDecl->getLocation(),
51         diag::err_class_redeclared_with_different_access)
52      << MemberDecl << LexicalAS;
53    Diag(PrevMemberDecl->getLocation(), diag::note_previous_access_declaration)
54      << PrevMemberDecl << PrevMemberDecl->getAccess();
55
56    MemberDecl->setAccess(LexicalAS);
57    return true;
58  }
59
60  MemberDecl->setAccess(PrevMemberDecl->getAccess());
61  return false;
62}
63
64static CXXRecordDecl *FindDeclaringClass(NamedDecl *D) {
65  DeclContext *DC = D->getDeclContext();
66
67  // This can only happen at top: enum decls only "publish" their
68  // immediate members.
69  if (isa<EnumDecl>(DC))
70    DC = cast<EnumDecl>(DC)->getDeclContext();
71
72  CXXRecordDecl *DeclaringClass = cast<CXXRecordDecl>(DC);
73  while (DeclaringClass->isAnonymousStructOrUnion())
74    DeclaringClass = cast<CXXRecordDecl>(DeclaringClass->getDeclContext());
75  return DeclaringClass;
76}
77
78namespace {
79struct EffectiveContext {
80  EffectiveContext() : Inner(0), Dependent(false) {}
81
82  explicit EffectiveContext(DeclContext *DC)
83    : Inner(DC),
84      Dependent(DC->isDependentContext()) {
85
86    // C++ [class.access.nest]p1:
87    //   A nested class is a member and as such has the same access
88    //   rights as any other member.
89    // C++ [class.access]p2:
90    //   A member of a class can also access all the names to which
91    //   the class has access.  A local class of a member function
92    //   may access the same names that the member function itself
93    //   may access.
94    // This almost implies that the privileges of nesting are transitive.
95    // Technically it says nothing about the local classes of non-member
96    // functions (which can gain privileges through friendship), but we
97    // take that as an oversight.
98    while (true) {
99      if (isa<CXXRecordDecl>(DC)) {
100        CXXRecordDecl *Record = cast<CXXRecordDecl>(DC)->getCanonicalDecl();
101        Records.push_back(Record);
102        DC = Record->getDeclContext();
103      } else if (isa<FunctionDecl>(DC)) {
104        FunctionDecl *Function = cast<FunctionDecl>(DC)->getCanonicalDecl();
105        Functions.push_back(Function);
106        DC = Function->getDeclContext();
107      } else if (DC->isFileContext()) {
108        break;
109      } else {
110        DC = DC->getParent();
111      }
112    }
113  }
114
115  bool isDependent() const { return Dependent; }
116
117  bool includesClass(const CXXRecordDecl *R) const {
118    R = R->getCanonicalDecl();
119    return std::find(Records.begin(), Records.end(), R)
120             != Records.end();
121  }
122
123  /// Retrieves the innermost "useful" context.  Can be null if we're
124  /// doing access-control without privileges.
125  DeclContext *getInnerContext() const {
126    return Inner;
127  }
128
129  typedef llvm::SmallVectorImpl<CXXRecordDecl*>::const_iterator record_iterator;
130
131  DeclContext *Inner;
132  llvm::SmallVector<FunctionDecl*, 4> Functions;
133  llvm::SmallVector<CXXRecordDecl*, 4> Records;
134  bool Dependent;
135};
136
137/// Like sema::AccessedEntity, but kindly lets us scribble all over
138/// it.
139struct AccessTarget : public AccessedEntity {
140  AccessTarget(const AccessedEntity &Entity)
141    : AccessedEntity(Entity) {
142    initialize();
143  }
144
145  AccessTarget(ASTContext &Context,
146               MemberNonce _,
147               CXXRecordDecl *NamingClass,
148               DeclAccessPair FoundDecl,
149               QualType BaseObjectType,
150               bool IsUsingDecl = false)
151    : AccessedEntity(Context, Member, NamingClass, FoundDecl, BaseObjectType),
152      IsUsingDeclaration(IsUsingDecl) {
153    initialize();
154  }
155
156  AccessTarget(ASTContext &Context,
157               BaseNonce _,
158               CXXRecordDecl *BaseClass,
159               CXXRecordDecl *DerivedClass,
160               AccessSpecifier Access)
161    : AccessedEntity(Context, Base, BaseClass, DerivedClass, Access) {
162    initialize();
163  }
164
165  bool hasInstanceContext() const {
166    return HasInstanceContext;
167  }
168
169  class SavedInstanceContext {
170  public:
171    ~SavedInstanceContext() {
172      Target.HasInstanceContext = Has;
173    }
174
175  private:
176    friend struct AccessTarget;
177    explicit SavedInstanceContext(AccessTarget &Target)
178      : Target(Target), Has(Target.HasInstanceContext) {}
179    AccessTarget &Target;
180    bool Has;
181  };
182
183  SavedInstanceContext saveInstanceContext() {
184    return SavedInstanceContext(*this);
185  }
186
187  void suppressInstanceContext() {
188    HasInstanceContext = false;
189  }
190
191  const CXXRecordDecl *resolveInstanceContext(Sema &S) const {
192    assert(HasInstanceContext);
193    if (CalculatedInstanceContext)
194      return InstanceContext;
195
196    CalculatedInstanceContext = true;
197    DeclContext *IC = S.computeDeclContext(getBaseObjectType());
198    InstanceContext = (IC ? cast<CXXRecordDecl>(IC)->getCanonicalDecl() : 0);
199    return InstanceContext;
200  }
201
202  const CXXRecordDecl *getDeclaringClass() const {
203    return DeclaringClass;
204  }
205
206private:
207  void initialize() {
208    HasInstanceContext = (isMemberAccess() &&
209                          !getBaseObjectType().isNull() &&
210                          getTargetDecl()->isCXXInstanceMember());
211    CalculatedInstanceContext = false;
212    InstanceContext = 0;
213
214    if (isMemberAccess())
215      DeclaringClass = FindDeclaringClass(getTargetDecl());
216    else
217      DeclaringClass = getBaseClass();
218    DeclaringClass = DeclaringClass->getCanonicalDecl();
219  }
220
221  bool IsUsingDeclaration : 1;
222  bool HasInstanceContext : 1;
223  mutable bool CalculatedInstanceContext : 1;
224  mutable const CXXRecordDecl *InstanceContext;
225  const CXXRecordDecl *DeclaringClass;
226};
227
228}
229
230/// Checks whether one class might instantiate to the other.
231static bool MightInstantiateTo(const CXXRecordDecl *From,
232                               const CXXRecordDecl *To) {
233  // Declaration names are always preserved by instantiation.
234  if (From->getDeclName() != To->getDeclName())
235    return false;
236
237  const DeclContext *FromDC = From->getDeclContext()->getPrimaryContext();
238  const DeclContext *ToDC = To->getDeclContext()->getPrimaryContext();
239  if (FromDC == ToDC) return true;
240  if (FromDC->isFileContext() || ToDC->isFileContext()) return false;
241
242  // Be conservative.
243  return true;
244}
245
246/// Checks whether one class is derived from another, inclusively.
247/// Properly indicates when it couldn't be determined due to
248/// dependence.
249///
250/// This should probably be donated to AST or at least Sema.
251static AccessResult IsDerivedFromInclusive(const CXXRecordDecl *Derived,
252                                           const CXXRecordDecl *Target) {
253  assert(Derived->getCanonicalDecl() == Derived);
254  assert(Target->getCanonicalDecl() == Target);
255
256  if (Derived == Target) return AR_accessible;
257
258  bool CheckDependent = Derived->isDependentContext();
259  if (CheckDependent && MightInstantiateTo(Derived, Target))
260    return AR_dependent;
261
262  AccessResult OnFailure = AR_inaccessible;
263  llvm::SmallVector<const CXXRecordDecl*, 8> Queue; // actually a stack
264
265  while (true) {
266    for (CXXRecordDecl::base_class_const_iterator
267           I = Derived->bases_begin(), E = Derived->bases_end(); I != E; ++I) {
268
269      const CXXRecordDecl *RD;
270
271      QualType T = I->getType();
272      if (const RecordType *RT = T->getAs<RecordType>()) {
273        RD = cast<CXXRecordDecl>(RT->getDecl());
274      } else if (const InjectedClassNameType *IT
275                   = T->getAs<InjectedClassNameType>()) {
276        RD = IT->getDecl();
277      } else {
278        assert(T->isDependentType() && "non-dependent base wasn't a record?");
279        OnFailure = AR_dependent;
280        continue;
281      }
282
283      RD = RD->getCanonicalDecl();
284      if (RD == Target) return AR_accessible;
285      if (CheckDependent && MightInstantiateTo(RD, Target))
286        OnFailure = AR_dependent;
287
288      Queue.push_back(RD);
289    }
290
291    if (Queue.empty()) break;
292
293    Derived = Queue.back();
294    Queue.pop_back();
295  }
296
297  return OnFailure;
298}
299
300
301static bool MightInstantiateTo(Sema &S, DeclContext *Context,
302                               DeclContext *Friend) {
303  if (Friend == Context)
304    return true;
305
306  assert(!Friend->isDependentContext() &&
307         "can't handle friends with dependent contexts here");
308
309  if (!Context->isDependentContext())
310    return false;
311
312  if (Friend->isFileContext())
313    return false;
314
315  // TODO: this is very conservative
316  return true;
317}
318
319// Asks whether the type in 'context' can ever instantiate to the type
320// in 'friend'.
321static bool MightInstantiateTo(Sema &S, CanQualType Context, CanQualType Friend) {
322  if (Friend == Context)
323    return true;
324
325  if (!Friend->isDependentType() && !Context->isDependentType())
326    return false;
327
328  // TODO: this is very conservative.
329  return true;
330}
331
332static bool MightInstantiateTo(Sema &S,
333                               FunctionDecl *Context,
334                               FunctionDecl *Friend) {
335  if (Context->getDeclName() != Friend->getDeclName())
336    return false;
337
338  if (!MightInstantiateTo(S,
339                          Context->getDeclContext(),
340                          Friend->getDeclContext()))
341    return false;
342
343  CanQual<FunctionProtoType> FriendTy
344    = S.Context.getCanonicalType(Friend->getType())
345         ->getAs<FunctionProtoType>();
346  CanQual<FunctionProtoType> ContextTy
347    = S.Context.getCanonicalType(Context->getType())
348         ->getAs<FunctionProtoType>();
349
350  // There isn't any way that I know of to add qualifiers
351  // during instantiation.
352  if (FriendTy.getQualifiers() != ContextTy.getQualifiers())
353    return false;
354
355  if (FriendTy->getNumArgs() != ContextTy->getNumArgs())
356    return false;
357
358  if (!MightInstantiateTo(S,
359                          ContextTy->getResultType(),
360                          FriendTy->getResultType()))
361    return false;
362
363  for (unsigned I = 0, E = FriendTy->getNumArgs(); I != E; ++I)
364    if (!MightInstantiateTo(S,
365                            ContextTy->getArgType(I),
366                            FriendTy->getArgType(I)))
367      return false;
368
369  return true;
370}
371
372static bool MightInstantiateTo(Sema &S,
373                               FunctionTemplateDecl *Context,
374                               FunctionTemplateDecl *Friend) {
375  return MightInstantiateTo(S,
376                            Context->getTemplatedDecl(),
377                            Friend->getTemplatedDecl());
378}
379
380static AccessResult MatchesFriend(Sema &S,
381                                  const EffectiveContext &EC,
382                                  const CXXRecordDecl *Friend) {
383  if (EC.includesClass(Friend))
384    return AR_accessible;
385
386  if (EC.isDependent()) {
387    CanQualType FriendTy
388      = S.Context.getCanonicalType(S.Context.getTypeDeclType(Friend));
389
390    for (EffectiveContext::record_iterator
391           I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {
392      CanQualType ContextTy
393        = S.Context.getCanonicalType(S.Context.getTypeDeclType(*I));
394      if (MightInstantiateTo(S, ContextTy, FriendTy))
395        return AR_dependent;
396    }
397  }
398
399  return AR_inaccessible;
400}
401
402static AccessResult MatchesFriend(Sema &S,
403                                  const EffectiveContext &EC,
404                                  CanQualType Friend) {
405  if (const RecordType *RT = Friend->getAs<RecordType>())
406    return MatchesFriend(S, EC, cast<CXXRecordDecl>(RT->getDecl()));
407
408  // TODO: we can do better than this
409  if (Friend->isDependentType())
410    return AR_dependent;
411
412  return AR_inaccessible;
413}
414
415/// Determines whether the given friend class template matches
416/// anything in the effective context.
417static AccessResult MatchesFriend(Sema &S,
418                                  const EffectiveContext &EC,
419                                  ClassTemplateDecl *Friend) {
420  AccessResult OnFailure = AR_inaccessible;
421
422  // Check whether the friend is the template of a class in the
423  // context chain.
424  for (llvm::SmallVectorImpl<CXXRecordDecl*>::const_iterator
425         I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {
426    CXXRecordDecl *Record = *I;
427
428    // Figure out whether the current class has a template:
429    ClassTemplateDecl *CTD;
430
431    // A specialization of the template...
432    if (isa<ClassTemplateSpecializationDecl>(Record)) {
433      CTD = cast<ClassTemplateSpecializationDecl>(Record)
434        ->getSpecializedTemplate();
435
436    // ... or the template pattern itself.
437    } else {
438      CTD = Record->getDescribedClassTemplate();
439      if (!CTD) continue;
440    }
441
442    // It's a match.
443    if (Friend == CTD->getCanonicalDecl())
444      return AR_accessible;
445
446    // If the context isn't dependent, it can't be a dependent match.
447    if (!EC.isDependent())
448      continue;
449
450    // If the template names don't match, it can't be a dependent
451    // match.
452    if (CTD->getDeclName() != Friend->getDeclName())
453      continue;
454
455    // If the class's context can't instantiate to the friend's
456    // context, it can't be a dependent match.
457    if (!MightInstantiateTo(S, CTD->getDeclContext(),
458                            Friend->getDeclContext()))
459      continue;
460
461    // Otherwise, it's a dependent match.
462    OnFailure = AR_dependent;
463  }
464
465  return OnFailure;
466}
467
468/// Determines whether the given friend function matches anything in
469/// the effective context.
470static AccessResult MatchesFriend(Sema &S,
471                                  const EffectiveContext &EC,
472                                  FunctionDecl *Friend) {
473  AccessResult OnFailure = AR_inaccessible;
474
475  for (llvm::SmallVectorImpl<FunctionDecl*>::const_iterator
476         I = EC.Functions.begin(), E = EC.Functions.end(); I != E; ++I) {
477    if (Friend == *I)
478      return AR_accessible;
479
480    if (EC.isDependent() && MightInstantiateTo(S, *I, Friend))
481      OnFailure = AR_dependent;
482  }
483
484  return OnFailure;
485}
486
487/// Determines whether the given friend function template matches
488/// anything in the effective context.
489static AccessResult MatchesFriend(Sema &S,
490                                  const EffectiveContext &EC,
491                                  FunctionTemplateDecl *Friend) {
492  if (EC.Functions.empty()) return AR_inaccessible;
493
494  AccessResult OnFailure = AR_inaccessible;
495
496  for (llvm::SmallVectorImpl<FunctionDecl*>::const_iterator
497         I = EC.Functions.begin(), E = EC.Functions.end(); I != E; ++I) {
498
499    FunctionTemplateDecl *FTD = (*I)->getPrimaryTemplate();
500    if (!FTD)
501      FTD = (*I)->getDescribedFunctionTemplate();
502    if (!FTD)
503      continue;
504
505    FTD = FTD->getCanonicalDecl();
506
507    if (Friend == FTD)
508      return AR_accessible;
509
510    if (EC.isDependent() && MightInstantiateTo(S, FTD, Friend))
511      OnFailure = AR_dependent;
512  }
513
514  return OnFailure;
515}
516
517/// Determines whether the given friend declaration matches anything
518/// in the effective context.
519static AccessResult MatchesFriend(Sema &S,
520                                  const EffectiveContext &EC,
521                                  FriendDecl *FriendD) {
522  // Whitelist accesses if there's an invalid or unsupported friend
523  // declaration.
524  if (FriendD->isInvalidDecl() || FriendD->isUnsupportedFriend())
525    return AR_accessible;
526
527  if (TypeSourceInfo *T = FriendD->getFriendType())
528    return MatchesFriend(S, EC, T->getType()->getCanonicalTypeUnqualified());
529
530  NamedDecl *Friend
531    = cast<NamedDecl>(FriendD->getFriendDecl()->getCanonicalDecl());
532
533  // FIXME: declarations with dependent or templated scope.
534
535  if (isa<ClassTemplateDecl>(Friend))
536    return MatchesFriend(S, EC, cast<ClassTemplateDecl>(Friend));
537
538  if (isa<FunctionTemplateDecl>(Friend))
539    return MatchesFriend(S, EC, cast<FunctionTemplateDecl>(Friend));
540
541  if (isa<CXXRecordDecl>(Friend))
542    return MatchesFriend(S, EC, cast<CXXRecordDecl>(Friend));
543
544  assert(isa<FunctionDecl>(Friend) && "unknown friend decl kind");
545  return MatchesFriend(S, EC, cast<FunctionDecl>(Friend));
546}
547
548static AccessResult GetFriendKind(Sema &S,
549                                  const EffectiveContext &EC,
550                                  const CXXRecordDecl *Class) {
551  AccessResult OnFailure = AR_inaccessible;
552
553  // Okay, check friends.
554  for (CXXRecordDecl::friend_iterator I = Class->friend_begin(),
555         E = Class->friend_end(); I != E; ++I) {
556    FriendDecl *Friend = *I;
557
558    switch (MatchesFriend(S, EC, Friend)) {
559    case AR_accessible:
560      return AR_accessible;
561
562    case AR_inaccessible:
563      continue;
564
565    case AR_dependent:
566      OnFailure = AR_dependent;
567      break;
568    }
569  }
570
571  // That's it, give up.
572  return OnFailure;
573}
574
575namespace {
576
577/// A helper class for checking for a friend which will grant access
578/// to a protected instance member.
579struct ProtectedFriendContext {
580  Sema &S;
581  const EffectiveContext &EC;
582  const CXXRecordDecl *NamingClass;
583  bool CheckDependent;
584  bool EverDependent;
585
586  /// The path down to the current base class.
587  llvm::SmallVector<const CXXRecordDecl*, 20> CurPath;
588
589  ProtectedFriendContext(Sema &S, const EffectiveContext &EC,
590                         const CXXRecordDecl *InstanceContext,
591                         const CXXRecordDecl *NamingClass)
592    : S(S), EC(EC), NamingClass(NamingClass),
593      CheckDependent(InstanceContext->isDependentContext() ||
594                     NamingClass->isDependentContext()),
595      EverDependent(false) {}
596
597  /// Check classes in the current path for friendship, starting at
598  /// the given index.
599  bool checkFriendshipAlongPath(unsigned I) {
600    assert(I < CurPath.size());
601    for (unsigned E = CurPath.size(); I != E; ++I) {
602      switch (GetFriendKind(S, EC, CurPath[I])) {
603      case AR_accessible:   return true;
604      case AR_inaccessible: continue;
605      case AR_dependent:    EverDependent = true; continue;
606      }
607    }
608    return false;
609  }
610
611  /// Perform a search starting at the given class.
612  ///
613  /// PrivateDepth is the index of the last (least derived) class
614  /// along the current path such that a notional public member of
615  /// the final class in the path would have access in that class.
616  bool findFriendship(const CXXRecordDecl *Cur, unsigned PrivateDepth) {
617    // If we ever reach the naming class, check the current path for
618    // friendship.  We can also stop recursing because we obviously
619    // won't find the naming class there again.
620    if (Cur == NamingClass)
621      return checkFriendshipAlongPath(PrivateDepth);
622
623    if (CheckDependent && MightInstantiateTo(Cur, NamingClass))
624      EverDependent = true;
625
626    // Recurse into the base classes.
627    for (CXXRecordDecl::base_class_const_iterator
628           I = Cur->bases_begin(), E = Cur->bases_end(); I != E; ++I) {
629
630      // If this is private inheritance, then a public member of the
631      // base will not have any access in classes derived from Cur.
632      unsigned BasePrivateDepth = PrivateDepth;
633      if (I->getAccessSpecifier() == AS_private)
634        BasePrivateDepth = CurPath.size() - 1;
635
636      const CXXRecordDecl *RD;
637
638      QualType T = I->getType();
639      if (const RecordType *RT = T->getAs<RecordType>()) {
640        RD = cast<CXXRecordDecl>(RT->getDecl());
641      } else if (const InjectedClassNameType *IT
642                   = T->getAs<InjectedClassNameType>()) {
643        RD = IT->getDecl();
644      } else {
645        assert(T->isDependentType() && "non-dependent base wasn't a record?");
646        EverDependent = true;
647        continue;
648      }
649
650      // Recurse.  We don't need to clean up if this returns true.
651      CurPath.push_back(RD);
652      if (findFriendship(RD->getCanonicalDecl(), BasePrivateDepth))
653        return true;
654      CurPath.pop_back();
655    }
656
657    return false;
658  }
659
660  bool findFriendship(const CXXRecordDecl *Cur) {
661    assert(CurPath.empty());
662    CurPath.push_back(Cur);
663    return findFriendship(Cur, 0);
664  }
665};
666}
667
668/// Search for a class P that EC is a friend of, under the constraint
669///   InstanceContext <= P <= NamingClass
670/// and with the additional restriction that a protected member of
671/// NamingClass would have some natural access in P.
672///
673/// That second condition isn't actually quite right: the condition in
674/// the standard is whether the target would have some natural access
675/// in P.  The difference is that the target might be more accessible
676/// along some path not passing through NamingClass.  Allowing that
677/// introduces two problems:
678///   - It breaks encapsulation because you can suddenly access a
679///     forbidden base class's members by subclassing it elsewhere.
680///   - It makes access substantially harder to compute because it
681///     breaks the hill-climbing algorithm: knowing that the target is
682///     accessible in some base class would no longer let you change
683///     the question solely to whether the base class is accessible,
684///     because the original target might have been more accessible
685///     because of crazy subclassing.
686/// So we don't implement that.
687static AccessResult GetProtectedFriendKind(Sema &S, const EffectiveContext &EC,
688                                           const CXXRecordDecl *InstanceContext,
689                                           const CXXRecordDecl *NamingClass) {
690  assert(InstanceContext->getCanonicalDecl() == InstanceContext);
691  assert(NamingClass->getCanonicalDecl() == NamingClass);
692
693  ProtectedFriendContext PRC(S, EC, InstanceContext, NamingClass);
694  if (PRC.findFriendship(InstanceContext)) return AR_accessible;
695  if (PRC.EverDependent) return AR_dependent;
696  return AR_inaccessible;
697}
698
699static AccessResult HasAccess(Sema &S,
700                              const EffectiveContext &EC,
701                              const CXXRecordDecl *NamingClass,
702                              AccessSpecifier Access,
703                              const AccessTarget &Target) {
704  assert(NamingClass->getCanonicalDecl() == NamingClass &&
705         "declaration should be canonicalized before being passed here");
706
707  if (Access == AS_public) return AR_accessible;
708  assert(Access == AS_private || Access == AS_protected);
709
710  AccessResult OnFailure = AR_inaccessible;
711
712  for (EffectiveContext::record_iterator
713         I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {
714    // All the declarations in EC have been canonicalized, so pointer
715    // equality from this point on will work fine.
716    const CXXRecordDecl *ECRecord = *I;
717
718    // [B2] and [M2]
719    if (Access == AS_private) {
720      if (ECRecord == NamingClass)
721        return AR_accessible;
722
723      if (EC.isDependent() && MightInstantiateTo(ECRecord, NamingClass))
724        OnFailure = AR_dependent;
725
726    // [B3] and [M3]
727    } else {
728      assert(Access == AS_protected);
729      switch (IsDerivedFromInclusive(ECRecord, NamingClass)) {
730      case AR_accessible: break;
731      case AR_inaccessible: continue;
732      case AR_dependent: OnFailure = AR_dependent; continue;
733      }
734
735      if (!Target.hasInstanceContext())
736        return AR_accessible;
737
738      const CXXRecordDecl *InstanceContext = Target.resolveInstanceContext(S);
739      if (!InstanceContext) {
740        OnFailure = AR_dependent;
741        continue;
742      }
743
744      // C++ [class.protected]p1:
745      //   An additional access check beyond those described earlier in
746      //   [class.access] is applied when a non-static data member or
747      //   non-static member function is a protected member of its naming
748      //   class.  As described earlier, access to a protected member is
749      //   granted because the reference occurs in a friend or member of
750      //   some class C.  If the access is to form a pointer to member,
751      //   the nested-name-specifier shall name C or a class derived from
752      //   C. All other accesses involve a (possibly implicit) object
753      //   expression. In this case, the class of the object expression
754      //   shall be C or a class derived from C.
755      //
756      // We interpret this as a restriction on [M3].  Most of the
757      // conditions are encoded by not having any instance context.
758      switch (IsDerivedFromInclusive(InstanceContext, ECRecord)) {
759      case AR_accessible: return AR_accessible;
760      case AR_inaccessible: continue;
761      case AR_dependent: OnFailure = AR_dependent; continue;
762      }
763    }
764  }
765
766  // [M3] and [B3] say that, if the target is protected in N, we grant
767  // access if the access occurs in a friend or member of some class P
768  // that's a subclass of N and where the target has some natural
769  // access in P.  The 'member' aspect is easy to handle because P
770  // would necessarily be one of the effective-context records, and we
771  // address that above.  The 'friend' aspect is completely ridiculous
772  // to implement because there are no restrictions at all on P
773  // *unless* the [class.protected] restriction applies.  If it does,
774  // however, we should ignore whether the naming class is a friend,
775  // and instead rely on whether any potential P is a friend.
776  if (Access == AS_protected && Target.hasInstanceContext()) {
777    const CXXRecordDecl *InstanceContext = Target.resolveInstanceContext(S);
778    if (!InstanceContext) return AR_dependent;
779    switch (GetProtectedFriendKind(S, EC, InstanceContext, NamingClass)) {
780    case AR_accessible: return AR_accessible;
781    case AR_inaccessible: return OnFailure;
782    case AR_dependent: return AR_dependent;
783    }
784    llvm_unreachable("impossible friendship kind");
785  }
786
787  switch (GetFriendKind(S, EC, NamingClass)) {
788  case AR_accessible: return AR_accessible;
789  case AR_inaccessible: return OnFailure;
790  case AR_dependent: return AR_dependent;
791  }
792
793  // Silence bogus warnings
794  llvm_unreachable("impossible friendship kind");
795  return OnFailure;
796}
797
798/// Finds the best path from the naming class to the declaring class,
799/// taking friend declarations into account.
800///
801/// C++0x [class.access.base]p5:
802///   A member m is accessible at the point R when named in class N if
803///   [M1] m as a member of N is public, or
804///   [M2] m as a member of N is private, and R occurs in a member or
805///        friend of class N, or
806///   [M3] m as a member of N is protected, and R occurs in a member or
807///        friend of class N, or in a member or friend of a class P
808///        derived from N, where m as a member of P is public, private,
809///        or protected, or
810///   [M4] there exists a base class B of N that is accessible at R, and
811///        m is accessible at R when named in class B.
812///
813/// C++0x [class.access.base]p4:
814///   A base class B of N is accessible at R, if
815///   [B1] an invented public member of B would be a public member of N, or
816///   [B2] R occurs in a member or friend of class N, and an invented public
817///        member of B would be a private or protected member of N, or
818///   [B3] R occurs in a member or friend of a class P derived from N, and an
819///        invented public member of B would be a private or protected member
820///        of P, or
821///   [B4] there exists a class S such that B is a base class of S accessible
822///        at R and S is a base class of N accessible at R.
823///
824/// Along a single inheritance path we can restate both of these
825/// iteratively:
826///
827/// First, we note that M1-4 are equivalent to B1-4 if the member is
828/// treated as a notional base of its declaring class with inheritance
829/// access equivalent to the member's access.  Therefore we need only
830/// ask whether a class B is accessible from a class N in context R.
831///
832/// Let B_1 .. B_n be the inheritance path in question (i.e. where
833/// B_1 = N, B_n = B, and for all i, B_{i+1} is a direct base class of
834/// B_i).  For i in 1..n, we will calculate ACAB(i), the access to the
835/// closest accessible base in the path:
836///   Access(a, b) = (* access on the base specifier from a to b *)
837///   Merge(a, forbidden) = forbidden
838///   Merge(a, private) = forbidden
839///   Merge(a, b) = min(a,b)
840///   Accessible(c, forbidden) = false
841///   Accessible(c, private) = (R is c) || IsFriend(c, R)
842///   Accessible(c, protected) = (R derived from c) || IsFriend(c, R)
843///   Accessible(c, public) = true
844///   ACAB(n) = public
845///   ACAB(i) =
846///     let AccessToBase = Merge(Access(B_i, B_{i+1}), ACAB(i+1)) in
847///     if Accessible(B_i, AccessToBase) then public else AccessToBase
848///
849/// B is an accessible base of N at R iff ACAB(1) = public.
850///
851/// \param FinalAccess the access of the "final step", or AS_public if
852///   there is no final step.
853/// \return null if friendship is dependent
854static CXXBasePath *FindBestPath(Sema &S,
855                                 const EffectiveContext &EC,
856                                 AccessTarget &Target,
857                                 AccessSpecifier FinalAccess,
858                                 CXXBasePaths &Paths) {
859  // Derive the paths to the desired base.
860  const CXXRecordDecl *Derived = Target.getNamingClass();
861  const CXXRecordDecl *Base = Target.getDeclaringClass();
862
863  // FIXME: fail correctly when there are dependent paths.
864  bool isDerived = Derived->isDerivedFrom(const_cast<CXXRecordDecl*>(Base),
865                                          Paths);
866  assert(isDerived && "derived class not actually derived from base");
867  (void) isDerived;
868
869  CXXBasePath *BestPath = 0;
870
871  assert(FinalAccess != AS_none && "forbidden access after declaring class");
872
873  bool AnyDependent = false;
874
875  // Derive the friend-modified access along each path.
876  for (CXXBasePaths::paths_iterator PI = Paths.begin(), PE = Paths.end();
877         PI != PE; ++PI) {
878    AccessTarget::SavedInstanceContext _ = Target.saveInstanceContext();
879
880    // Walk through the path backwards.
881    AccessSpecifier PathAccess = FinalAccess;
882    CXXBasePath::iterator I = PI->end(), E = PI->begin();
883    while (I != E) {
884      --I;
885
886      assert(PathAccess != AS_none);
887
888      // If the declaration is a private member of a base class, there
889      // is no level of friendship in derived classes that can make it
890      // accessible.
891      if (PathAccess == AS_private) {
892        PathAccess = AS_none;
893        break;
894      }
895
896      const CXXRecordDecl *NC = I->Class->getCanonicalDecl();
897
898      AccessSpecifier BaseAccess = I->Base->getAccessSpecifier();
899      PathAccess = std::max(PathAccess, BaseAccess);
900
901      switch (HasAccess(S, EC, NC, PathAccess, Target)) {
902      case AR_inaccessible: break;
903      case AR_accessible:
904        PathAccess = AS_public;
905
906        // Future tests are not against members and so do not have
907        // instance context.
908        Target.suppressInstanceContext();
909        break;
910      case AR_dependent:
911        AnyDependent = true;
912        goto Next;
913      }
914    }
915
916    // Note that we modify the path's Access field to the
917    // friend-modified access.
918    if (BestPath == 0 || PathAccess < BestPath->Access) {
919      BestPath = &*PI;
920      BestPath->Access = PathAccess;
921
922      // Short-circuit if we found a public path.
923      if (BestPath->Access == AS_public)
924        return BestPath;
925    }
926
927  Next: ;
928  }
929
930  assert((!BestPath || BestPath->Access != AS_public) &&
931         "fell out of loop with public path");
932
933  // We didn't find a public path, but at least one path was subject
934  // to dependent friendship, so delay the check.
935  if (AnyDependent)
936    return 0;
937
938  return BestPath;
939}
940
941/// Given that an entity has protected natural access, check whether
942/// access might be denied because of the protected member access
943/// restriction.
944///
945/// \return true if a note was emitted
946static bool TryDiagnoseProtectedAccess(Sema &S, const EffectiveContext &EC,
947                                       AccessTarget &Target) {
948  // Only applies to instance accesses.
949  if (!Target.hasInstanceContext())
950    return false;
951  assert(Target.isMemberAccess());
952  NamedDecl *D = Target.getTargetDecl();
953
954  const CXXRecordDecl *DeclaringClass = Target.getDeclaringClass();
955  DeclaringClass = DeclaringClass->getCanonicalDecl();
956
957  for (EffectiveContext::record_iterator
958         I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {
959    const CXXRecordDecl *ECRecord = *I;
960    switch (IsDerivedFromInclusive(ECRecord, DeclaringClass)) {
961    case AR_accessible: break;
962    case AR_inaccessible: continue;
963    case AR_dependent: continue;
964    }
965
966    // The effective context is a subclass of the declaring class.
967    // If that class isn't a superclass of the instance context,
968    // then the [class.protected] restriction applies.
969
970    // To get this exactly right, this might need to be checked more
971    // holistically;  it's not necessarily the case that gaining
972    // access here would grant us access overall.
973
974    const CXXRecordDecl *InstanceContext = Target.resolveInstanceContext(S);
975    assert(InstanceContext && "diagnosing dependent access");
976
977    switch (IsDerivedFromInclusive(InstanceContext, ECRecord)) {
978    case AR_accessible: continue;
979    case AR_dependent: continue;
980    case AR_inaccessible:
981      S.Diag(D->getLocation(), diag::note_access_protected_restricted)
982        << (InstanceContext != Target.getNamingClass()->getCanonicalDecl())
983        << S.Context.getTypeDeclType(InstanceContext)
984        << S.Context.getTypeDeclType(ECRecord);
985      return true;
986    }
987  }
988
989  return false;
990}
991
992/// Diagnose the path which caused the given declaration or base class
993/// to become inaccessible.
994static void DiagnoseAccessPath(Sema &S,
995                               const EffectiveContext &EC,
996                               AccessTarget &Entity) {
997  AccessSpecifier Access = Entity.getAccess();
998  const CXXRecordDecl *NamingClass = Entity.getNamingClass();
999  NamingClass = NamingClass->getCanonicalDecl();
1000
1001  NamedDecl *D = (Entity.isMemberAccess() ? Entity.getTargetDecl() : 0);
1002  const CXXRecordDecl *DeclaringClass = Entity.getDeclaringClass();
1003
1004  // Easy case: the decl's natural access determined its path access.
1005  // We have to check against AS_private here in case Access is AS_none,
1006  // indicating a non-public member of a private base class.
1007  if (D && (Access == D->getAccess() || D->getAccess() == AS_private)) {
1008    switch (HasAccess(S, EC, DeclaringClass, D->getAccess(), Entity)) {
1009    case AR_inaccessible: {
1010      if (Access == AS_protected &&
1011          TryDiagnoseProtectedAccess(S, EC, Entity))
1012        return;
1013
1014      // Find an original declaration.
1015      while (D->isOutOfLine()) {
1016        NamedDecl *PrevDecl = 0;
1017        if (VarDecl *VD = dyn_cast<VarDecl>(D))
1018          PrevDecl = VD->getPreviousDeclaration();
1019        else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
1020          PrevDecl = FD->getPreviousDeclaration();
1021        else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(D))
1022          PrevDecl = TND->getPreviousDeclaration();
1023        else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1024          if (isa<RecordDecl>(D) && cast<RecordDecl>(D)->isInjectedClassName())
1025            break;
1026          PrevDecl = TD->getPreviousDeclaration();
1027        }
1028        if (!PrevDecl) break;
1029        D = PrevDecl;
1030      }
1031
1032      CXXRecordDecl *DeclaringClass = FindDeclaringClass(D);
1033      Decl *ImmediateChild;
1034      if (D->getDeclContext() == DeclaringClass)
1035        ImmediateChild = D;
1036      else {
1037        DeclContext *DC = D->getDeclContext();
1038        while (DC->getParent() != DeclaringClass)
1039          DC = DC->getParent();
1040        ImmediateChild = cast<Decl>(DC);
1041      }
1042
1043      // Check whether there's an AccessSpecDecl preceding this in the
1044      // chain of the DeclContext.
1045      bool Implicit = true;
1046      for (CXXRecordDecl::decl_iterator
1047             I = DeclaringClass->decls_begin(), E = DeclaringClass->decls_end();
1048           I != E; ++I) {
1049        if (*I == ImmediateChild) break;
1050        if (isa<AccessSpecDecl>(*I)) {
1051          Implicit = false;
1052          break;
1053        }
1054      }
1055
1056      S.Diag(D->getLocation(), diag::note_access_natural)
1057        << (unsigned) (Access == AS_protected)
1058        << Implicit;
1059      return;
1060    }
1061
1062    case AR_accessible: break;
1063
1064    case AR_dependent:
1065      llvm_unreachable("can't diagnose dependent access failures");
1066      return;
1067    }
1068  }
1069
1070  CXXBasePaths Paths;
1071  CXXBasePath &Path = *FindBestPath(S, EC, Entity, AS_public, Paths);
1072
1073  CXXBasePath::iterator I = Path.end(), E = Path.begin();
1074  while (I != E) {
1075    --I;
1076
1077    const CXXBaseSpecifier *BS = I->Base;
1078    AccessSpecifier BaseAccess = BS->getAccessSpecifier();
1079
1080    // If this is public inheritance, or the derived class is a friend,
1081    // skip this step.
1082    if (BaseAccess == AS_public)
1083      continue;
1084
1085    switch (GetFriendKind(S, EC, I->Class)) {
1086    case AR_accessible: continue;
1087    case AR_inaccessible: break;
1088    case AR_dependent:
1089      llvm_unreachable("can't diagnose dependent access failures");
1090    }
1091
1092    // Check whether this base specifier is the tighest point
1093    // constraining access.  We have to check against AS_private for
1094    // the same reasons as above.
1095    if (BaseAccess == AS_private || BaseAccess >= Access) {
1096
1097      // We're constrained by inheritance, but we want to say
1098      // "declared private here" if we're diagnosing a hierarchy
1099      // conversion and this is the final step.
1100      unsigned diagnostic;
1101      if (D) diagnostic = diag::note_access_constrained_by_path;
1102      else if (I + 1 == Path.end()) diagnostic = diag::note_access_natural;
1103      else diagnostic = diag::note_access_constrained_by_path;
1104
1105      S.Diag(BS->getSourceRange().getBegin(), diagnostic)
1106        << BS->getSourceRange()
1107        << (BaseAccess == AS_protected)
1108        << (BS->getAccessSpecifierAsWritten() == AS_none);
1109
1110      if (D)
1111        S.Diag(D->getLocation(), diag::note_field_decl);
1112
1113      return;
1114    }
1115  }
1116
1117  llvm_unreachable("access not apparently constrained by path");
1118}
1119
1120static void DiagnoseBadAccess(Sema &S, SourceLocation Loc,
1121                              const EffectiveContext &EC,
1122                              AccessTarget &Entity) {
1123  const CXXRecordDecl *NamingClass = Entity.getNamingClass();
1124  const CXXRecordDecl *DeclaringClass = Entity.getDeclaringClass();
1125  NamedDecl *D = (Entity.isMemberAccess() ? Entity.getTargetDecl() : 0);
1126
1127  S.Diag(Loc, Entity.getDiag())
1128    << (Entity.getAccess() == AS_protected)
1129    << (D ? D->getDeclName() : DeclarationName())
1130    << S.Context.getTypeDeclType(NamingClass)
1131    << S.Context.getTypeDeclType(DeclaringClass);
1132  DiagnoseAccessPath(S, EC, Entity);
1133}
1134
1135/// MSVC has a bug where if during an using declaration name lookup,
1136/// the declaration found is unaccessible (private) and that declaration
1137/// was bring into scope via another using declaration whose target
1138/// declaration is accessible (public) then no error is generated.
1139/// Example:
1140///   class A {
1141///   public:
1142///     int f();
1143///   };
1144///   class B : public A {
1145///   private:
1146///     using A::f;
1147///   };
1148///   class C : public B {
1149///   private:
1150///     using B::f;
1151///   };
1152///
1153/// Here, B::f is private so this should fail in Standard C++, but
1154/// because B::f refers to A::f which is public MSVC accepts it.
1155static bool IsMicrosoftUsingDeclarationAccessBug(Sema& S,
1156                                                 SourceLocation AccessLoc,
1157                                                 AccessTarget &Entity) {
1158  if (UsingShadowDecl *Shadow =
1159                         dyn_cast<UsingShadowDecl>(Entity.getTargetDecl())) {
1160    const NamedDecl *OrigDecl = Entity.getTargetDecl()->getUnderlyingDecl();
1161    if (Entity.getTargetDecl()->getAccess() == AS_private &&
1162        (OrigDecl->getAccess() == AS_public ||
1163         OrigDecl->getAccess() == AS_protected)) {
1164      S.Diag(AccessLoc, diag::war_ms_using_declaration_inaccessible)
1165        << Shadow->getUsingDecl()->getQualifiedNameAsString()
1166        << OrigDecl->getQualifiedNameAsString();
1167      return true;
1168    }
1169  }
1170  return false;
1171}
1172
1173/// Determines whether the accessed entity is accessible.  Public members
1174/// have been weeded out by this point.
1175static AccessResult IsAccessible(Sema &S,
1176                                 const EffectiveContext &EC,
1177                                 AccessTarget &Entity) {
1178  // Determine the actual naming class.
1179  CXXRecordDecl *NamingClass = Entity.getNamingClass();
1180  while (NamingClass->isAnonymousStructOrUnion())
1181    NamingClass = cast<CXXRecordDecl>(NamingClass->getParent());
1182  NamingClass = NamingClass->getCanonicalDecl();
1183
1184  AccessSpecifier UnprivilegedAccess = Entity.getAccess();
1185  assert(UnprivilegedAccess != AS_public && "public access not weeded out");
1186
1187  // Before we try to recalculate access paths, try to white-list
1188  // accesses which just trade in on the final step, i.e. accesses
1189  // which don't require [M4] or [B4]. These are by far the most
1190  // common forms of privileged access.
1191  if (UnprivilegedAccess != AS_none) {
1192    switch (HasAccess(S, EC, NamingClass, UnprivilegedAccess, Entity)) {
1193    case AR_dependent:
1194      // This is actually an interesting policy decision.  We don't
1195      // *have* to delay immediately here: we can do the full access
1196      // calculation in the hope that friendship on some intermediate
1197      // class will make the declaration accessible non-dependently.
1198      // But that's not cheap, and odds are very good (note: assertion
1199      // made without data) that the friend declaration will determine
1200      // access.
1201      return AR_dependent;
1202
1203    case AR_accessible: return AR_accessible;
1204    case AR_inaccessible: break;
1205    }
1206  }
1207
1208  AccessTarget::SavedInstanceContext _ = Entity.saveInstanceContext();
1209
1210  // We lower member accesses to base accesses by pretending that the
1211  // member is a base class of its declaring class.
1212  AccessSpecifier FinalAccess;
1213
1214  if (Entity.isMemberAccess()) {
1215    // Determine if the declaration is accessible from EC when named
1216    // in its declaring class.
1217    NamedDecl *Target = Entity.getTargetDecl();
1218    const CXXRecordDecl *DeclaringClass = Entity.getDeclaringClass();
1219
1220    FinalAccess = Target->getAccess();
1221    switch (HasAccess(S, EC, DeclaringClass, FinalAccess, Entity)) {
1222    case AR_accessible:
1223      FinalAccess = AS_public;
1224      break;
1225    case AR_inaccessible: break;
1226    case AR_dependent: return AR_dependent; // see above
1227    }
1228
1229    if (DeclaringClass == NamingClass)
1230      return (FinalAccess == AS_public ? AR_accessible : AR_inaccessible);
1231
1232    Entity.suppressInstanceContext();
1233  } else {
1234    FinalAccess = AS_public;
1235  }
1236
1237  assert(Entity.getDeclaringClass() != NamingClass);
1238
1239  // Append the declaration's access if applicable.
1240  CXXBasePaths Paths;
1241  CXXBasePath *Path = FindBestPath(S, EC, Entity, FinalAccess, Paths);
1242  if (!Path)
1243    return AR_dependent;
1244
1245  assert(Path->Access <= UnprivilegedAccess &&
1246         "access along best path worse than direct?");
1247  if (Path->Access == AS_public)
1248    return AR_accessible;
1249  return AR_inaccessible;
1250}
1251
1252static void DelayDependentAccess(Sema &S,
1253                                 const EffectiveContext &EC,
1254                                 SourceLocation Loc,
1255                                 const AccessTarget &Entity) {
1256  assert(EC.isDependent() && "delaying non-dependent access");
1257  DeclContext *DC = EC.getInnerContext();
1258  assert(DC->isDependentContext() && "delaying non-dependent access");
1259  DependentDiagnostic::Create(S.Context, DC, DependentDiagnostic::Access,
1260                              Loc,
1261                              Entity.isMemberAccess(),
1262                              Entity.getAccess(),
1263                              Entity.getTargetDecl(),
1264                              Entity.getNamingClass(),
1265                              Entity.getBaseObjectType(),
1266                              Entity.getDiag());
1267}
1268
1269/// Checks access to an entity from the given effective context.
1270static AccessResult CheckEffectiveAccess(Sema &S,
1271                                         const EffectiveContext &EC,
1272                                         SourceLocation Loc,
1273                                         AccessTarget &Entity) {
1274  assert(Entity.getAccess() != AS_public && "called for public access!");
1275
1276  if (S.getLangOptions().Microsoft &&
1277      IsMicrosoftUsingDeclarationAccessBug(S, Loc, Entity))
1278    return AR_accessible;
1279
1280  switch (IsAccessible(S, EC, Entity)) {
1281  case AR_dependent:
1282    DelayDependentAccess(S, EC, Loc, Entity);
1283    return AR_dependent;
1284
1285  case AR_inaccessible:
1286    if (!Entity.isQuiet())
1287      DiagnoseBadAccess(S, Loc, EC, Entity);
1288    return AR_inaccessible;
1289
1290  case AR_accessible:
1291    return AR_accessible;
1292  }
1293
1294  // silence unnecessary warning
1295  llvm_unreachable("invalid access result");
1296  return AR_accessible;
1297}
1298
1299static Sema::AccessResult CheckAccess(Sema &S, SourceLocation Loc,
1300                                      AccessTarget &Entity) {
1301  // If the access path is public, it's accessible everywhere.
1302  if (Entity.getAccess() == AS_public)
1303    return Sema::AR_accessible;
1304
1305  if (S.SuppressAccessChecking)
1306    return Sema::AR_accessible;
1307
1308  // If we're currently parsing a declaration, we may need to delay
1309  // access control checking, because our effective context might be
1310  // different based on what the declaration comes out as.
1311  //
1312  // For example, we might be parsing a declaration with a scope
1313  // specifier, like this:
1314  //   A::private_type A::foo() { ... }
1315  //
1316  // Or we might be parsing something that will turn out to be a friend:
1317  //   void foo(A::private_type);
1318  //   void B::foo(A::private_type);
1319  if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {
1320    S.DelayedDiagnostics.add(DelayedDiagnostic::makeAccess(Loc, Entity));
1321    return Sema::AR_delayed;
1322  }
1323
1324  EffectiveContext EC(S.CurContext);
1325  switch (CheckEffectiveAccess(S, EC, Loc, Entity)) {
1326  case AR_accessible: return Sema::AR_accessible;
1327  case AR_inaccessible: return Sema::AR_inaccessible;
1328  case AR_dependent: return Sema::AR_dependent;
1329  }
1330  llvm_unreachable("falling off end");
1331  return Sema::AR_accessible;
1332}
1333
1334void Sema::HandleDelayedAccessCheck(DelayedDiagnostic &DD, Decl *decl) {
1335  // Access control for names used in the declarations of functions
1336  // and function templates should normally be evaluated in the context
1337  // of the declaration, just in case it's a friend of something.
1338  // However, this does not apply to local extern declarations.
1339
1340  DeclContext *DC = decl->getDeclContext();
1341  if (FunctionDecl *fn = dyn_cast<FunctionDecl>(decl)) {
1342    if (!DC->isFunctionOrMethod()) DC = fn;
1343  } else if (FunctionTemplateDecl *fnt = dyn_cast<FunctionTemplateDecl>(decl)) {
1344    // Never a local declaration.
1345    DC = fnt->getTemplatedDecl();
1346  }
1347
1348  EffectiveContext EC(DC);
1349
1350  AccessTarget Target(DD.getAccessData());
1351
1352  if (CheckEffectiveAccess(*this, EC, DD.Loc, Target) == ::AR_inaccessible)
1353    DD.Triggered = true;
1354}
1355
1356void Sema::HandleDependentAccessCheck(const DependentDiagnostic &DD,
1357                        const MultiLevelTemplateArgumentList &TemplateArgs) {
1358  SourceLocation Loc = DD.getAccessLoc();
1359  AccessSpecifier Access = DD.getAccess();
1360
1361  Decl *NamingD = FindInstantiatedDecl(Loc, DD.getAccessNamingClass(),
1362                                       TemplateArgs);
1363  if (!NamingD) return;
1364  Decl *TargetD = FindInstantiatedDecl(Loc, DD.getAccessTarget(),
1365                                       TemplateArgs);
1366  if (!TargetD) return;
1367
1368  if (DD.isAccessToMember()) {
1369    CXXRecordDecl *NamingClass = cast<CXXRecordDecl>(NamingD);
1370    NamedDecl *TargetDecl = cast<NamedDecl>(TargetD);
1371    QualType BaseObjectType = DD.getAccessBaseObjectType();
1372    if (!BaseObjectType.isNull()) {
1373      BaseObjectType = SubstType(BaseObjectType, TemplateArgs, Loc,
1374                                 DeclarationName());
1375      if (BaseObjectType.isNull()) return;
1376    }
1377
1378    AccessTarget Entity(Context,
1379                        AccessTarget::Member,
1380                        NamingClass,
1381                        DeclAccessPair::make(TargetDecl, Access),
1382                        BaseObjectType);
1383    Entity.setDiag(DD.getDiagnostic());
1384    CheckAccess(*this, Loc, Entity);
1385  } else {
1386    AccessTarget Entity(Context,
1387                        AccessTarget::Base,
1388                        cast<CXXRecordDecl>(TargetD),
1389                        cast<CXXRecordDecl>(NamingD),
1390                        Access);
1391    Entity.setDiag(DD.getDiagnostic());
1392    CheckAccess(*this, Loc, Entity);
1393  }
1394}
1395
1396Sema::AccessResult Sema::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,
1397                                                     DeclAccessPair Found) {
1398  if (!getLangOptions().AccessControl ||
1399      !E->getNamingClass() ||
1400      Found.getAccess() == AS_public)
1401    return AR_accessible;
1402
1403  AccessTarget Entity(Context, AccessTarget::Member, E->getNamingClass(),
1404                      Found, QualType());
1405  Entity.setDiag(diag::err_access) << E->getSourceRange();
1406
1407  return CheckAccess(*this, E->getNameLoc(), Entity);
1408}
1409
1410/// Perform access-control checking on a previously-unresolved member
1411/// access which has now been resolved to a member.
1412Sema::AccessResult Sema::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,
1413                                                     DeclAccessPair Found) {
1414  if (!getLangOptions().AccessControl ||
1415      Found.getAccess() == AS_public)
1416    return AR_accessible;
1417
1418  QualType BaseType = E->getBaseType();
1419  if (E->isArrow())
1420    BaseType = BaseType->getAs<PointerType>()->getPointeeType();
1421
1422  AccessTarget Entity(Context, AccessTarget::Member, E->getNamingClass(),
1423                      Found, BaseType);
1424  Entity.setDiag(diag::err_access) << E->getSourceRange();
1425
1426  return CheckAccess(*this, E->getMemberLoc(), Entity);
1427}
1428
1429Sema::AccessResult Sema::CheckDestructorAccess(SourceLocation Loc,
1430                                               CXXDestructorDecl *Dtor,
1431                                               const PartialDiagnostic &PDiag) {
1432  if (!getLangOptions().AccessControl)
1433    return AR_accessible;
1434
1435  // There's never a path involved when checking implicit destructor access.
1436  AccessSpecifier Access = Dtor->getAccess();
1437  if (Access == AS_public)
1438    return AR_accessible;
1439
1440  CXXRecordDecl *NamingClass = Dtor->getParent();
1441  AccessTarget Entity(Context, AccessTarget::Member, NamingClass,
1442                      DeclAccessPair::make(Dtor, Access),
1443                      QualType());
1444  Entity.setDiag(PDiag); // TODO: avoid copy
1445
1446  return CheckAccess(*this, Loc, Entity);
1447}
1448
1449/// Checks access to a constructor.
1450Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc,
1451                                                CXXConstructorDecl *Constructor,
1452                                                const InitializedEntity &Entity,
1453                                                AccessSpecifier Access,
1454                                                bool IsCopyBindingRefToTemp) {
1455  if (!getLangOptions().AccessControl ||
1456      Access == AS_public)
1457    return AR_accessible;
1458
1459  CXXRecordDecl *NamingClass = Constructor->getParent();
1460  AccessTarget AccessEntity(Context, AccessTarget::Member, NamingClass,
1461                            DeclAccessPair::make(Constructor, Access),
1462                            QualType());
1463  PartialDiagnostic PD(PDiag());
1464  switch (Entity.getKind()) {
1465  default:
1466    PD = PDiag(IsCopyBindingRefToTemp
1467                 ? diag::ext_rvalue_to_reference_access_ctor
1468                 : diag::err_access_ctor);
1469
1470    break;
1471
1472  case InitializedEntity::EK_Base:
1473    PD = PDiag(diag::err_access_base_ctor);
1474    PD << Entity.isInheritedVirtualBase()
1475       << Entity.getBaseSpecifier()->getType() << getSpecialMember(Constructor);
1476    break;
1477
1478  case InitializedEntity::EK_Member: {
1479    const FieldDecl *Field = cast<FieldDecl>(Entity.getDecl());
1480    PD = PDiag(diag::err_access_field_ctor);
1481    PD << Field->getType() << getSpecialMember(Constructor);
1482    break;
1483  }
1484
1485  }
1486
1487  return CheckConstructorAccess(UseLoc, Constructor, Access, PD);
1488}
1489
1490/// Checks access to a constructor.
1491Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc,
1492                                                CXXConstructorDecl *Constructor,
1493                                                AccessSpecifier Access,
1494                                                PartialDiagnostic PD) {
1495  if (!getLangOptions().AccessControl ||
1496      Access == AS_public)
1497    return AR_accessible;
1498
1499  CXXRecordDecl *NamingClass = Constructor->getParent();
1500  AccessTarget AccessEntity(Context, AccessTarget::Member, NamingClass,
1501                            DeclAccessPair::make(Constructor, Access),
1502                            QualType());
1503  AccessEntity.setDiag(PD);
1504
1505  return CheckAccess(*this, UseLoc, AccessEntity);
1506}
1507
1508/// Checks direct (i.e. non-inherited) access to an arbitrary class
1509/// member.
1510Sema::AccessResult Sema::CheckDirectMemberAccess(SourceLocation UseLoc,
1511                                                 NamedDecl *Target,
1512                                           const PartialDiagnostic &Diag) {
1513  AccessSpecifier Access = Target->getAccess();
1514  if (!getLangOptions().AccessControl ||
1515      Access == AS_public)
1516    return AR_accessible;
1517
1518  CXXRecordDecl *NamingClass = cast<CXXRecordDecl>(Target->getDeclContext());
1519  AccessTarget Entity(Context, AccessTarget::Member, NamingClass,
1520                      DeclAccessPair::make(Target, Access),
1521                      QualType());
1522  Entity.setDiag(Diag);
1523  return CheckAccess(*this, UseLoc, Entity);
1524}
1525
1526
1527/// Checks access to an overloaded operator new or delete.
1528Sema::AccessResult Sema::CheckAllocationAccess(SourceLocation OpLoc,
1529                                               SourceRange PlacementRange,
1530                                               CXXRecordDecl *NamingClass,
1531                                               DeclAccessPair Found,
1532                                               bool Diagnose) {
1533  if (!getLangOptions().AccessControl ||
1534      !NamingClass ||
1535      Found.getAccess() == AS_public)
1536    return AR_accessible;
1537
1538  AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found,
1539                      QualType());
1540  if (Diagnose)
1541    Entity.setDiag(diag::err_access)
1542      << PlacementRange;
1543
1544  return CheckAccess(*this, OpLoc, Entity);
1545}
1546
1547/// Checks access to an overloaded member operator, including
1548/// conversion operators.
1549Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc,
1550                                                   Expr *ObjectExpr,
1551                                                   Expr *ArgExpr,
1552                                                   DeclAccessPair Found) {
1553  if (!getLangOptions().AccessControl ||
1554      Found.getAccess() == AS_public)
1555    return AR_accessible;
1556
1557  const RecordType *RT = ObjectExpr->getType()->getAs<RecordType>();
1558  assert(RT && "found member operator but object expr not of record type");
1559  CXXRecordDecl *NamingClass = cast<CXXRecordDecl>(RT->getDecl());
1560
1561  AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found,
1562                      ObjectExpr->getType());
1563  Entity.setDiag(diag::err_access)
1564    << ObjectExpr->getSourceRange()
1565    << (ArgExpr ? ArgExpr->getSourceRange() : SourceRange());
1566
1567  return CheckAccess(*this, OpLoc, Entity);
1568}
1569
1570Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr,
1571                                                    DeclAccessPair Found) {
1572  if (!getLangOptions().AccessControl ||
1573      Found.getAccess() == AS_none ||
1574      Found.getAccess() == AS_public)
1575    return AR_accessible;
1576
1577  OverloadExpr *Ovl = OverloadExpr::find(OvlExpr).Expression;
1578  CXXRecordDecl *NamingClass = Ovl->getNamingClass();
1579
1580  AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found,
1581                      Context.getTypeDeclType(NamingClass));
1582  Entity.setDiag(diag::err_access)
1583    << Ovl->getSourceRange();
1584
1585  return CheckAccess(*this, Ovl->getNameLoc(), Entity);
1586}
1587
1588/// Checks access for a hierarchy conversion.
1589///
1590/// \param IsBaseToDerived whether this is a base-to-derived conversion (true)
1591///     or a derived-to-base conversion (false)
1592/// \param ForceCheck true if this check should be performed even if access
1593///     control is disabled;  some things rely on this for semantics
1594/// \param ForceUnprivileged true if this check should proceed as if the
1595///     context had no special privileges
1596/// \param ADK controls the kind of diagnostics that are used
1597Sema::AccessResult Sema::CheckBaseClassAccess(SourceLocation AccessLoc,
1598                                              QualType Base,
1599                                              QualType Derived,
1600                                              const CXXBasePath &Path,
1601                                              unsigned DiagID,
1602                                              bool ForceCheck,
1603                                              bool ForceUnprivileged) {
1604  if (!ForceCheck && !getLangOptions().AccessControl)
1605    return AR_accessible;
1606
1607  if (Path.Access == AS_public)
1608    return AR_accessible;
1609
1610  CXXRecordDecl *BaseD, *DerivedD;
1611  BaseD = cast<CXXRecordDecl>(Base->getAs<RecordType>()->getDecl());
1612  DerivedD = cast<CXXRecordDecl>(Derived->getAs<RecordType>()->getDecl());
1613
1614  AccessTarget Entity(Context, AccessTarget::Base, BaseD, DerivedD,
1615                      Path.Access);
1616  if (DiagID)
1617    Entity.setDiag(DiagID) << Derived << Base;
1618
1619  if (ForceUnprivileged) {
1620    switch (CheckEffectiveAccess(*this, EffectiveContext(),
1621                                 AccessLoc, Entity)) {
1622    case ::AR_accessible: return Sema::AR_accessible;
1623    case ::AR_inaccessible: return Sema::AR_inaccessible;
1624    case ::AR_dependent: return Sema::AR_dependent;
1625    }
1626    llvm_unreachable("unexpected result from CheckEffectiveAccess");
1627  }
1628  return CheckAccess(*this, AccessLoc, Entity);
1629}
1630
1631/// Checks access to all the declarations in the given result set.
1632void Sema::CheckLookupAccess(const LookupResult &R) {
1633  assert(getLangOptions().AccessControl
1634         && "performing access check without access control");
1635  assert(R.getNamingClass() && "performing access check without naming class");
1636
1637  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
1638    if (I.getAccess() != AS_public) {
1639      AccessTarget Entity(Context, AccessedEntity::Member,
1640                          R.getNamingClass(), I.getPair(),
1641                          R.getBaseObjectType(), R.isUsingDeclaration());
1642      Entity.setDiag(diag::err_access);
1643      CheckAccess(*this, R.getNameLoc(), Entity);
1644    }
1645  }
1646}
1647
1648void Sema::ActOnStartSuppressingAccessChecks() {
1649  assert(!SuppressAccessChecking &&
1650         "Tried to start access check suppression when already started.");
1651  SuppressAccessChecking = true;
1652}
1653
1654void Sema::ActOnStopSuppressingAccessChecks() {
1655  assert(SuppressAccessChecking &&
1656         "Tried to stop access check suprression when already stopped.");
1657  SuppressAccessChecking = false;
1658}
1659