clang  6.0.0svn
SemaAccess.cpp
Go to the documentation of this file.
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 
15 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclFriend.h"
19 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/ExprCXX.h"
24 #include "clang/Sema/Lookup.h"
25 
26 using namespace clang;
27 using namespace sema;
28 
29 /// A copy of Sema's enum without AR_delayed.
34 };
35 
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).
40  NamedDecl *PrevMemberDecl,
41  AccessSpecifier LexicalAS) {
42  if (!PrevMemberDecl) {
43  // Use the lexical access specifier.
44  MemberDecl->setAccess(LexicalAS);
45  return false;
46  }
47 
48  // C++ [class.access.spec]p3: When a member is redeclared its access
49  // specifier must be same as its initial declaration.
50  if (LexicalAS != AS_none && LexicalAS != PrevMemberDecl->getAccess()) {
51  Diag(MemberDecl->getLocation(),
52  diag::err_class_redeclared_with_different_access)
53  << MemberDecl << LexicalAS;
54  Diag(PrevMemberDecl->getLocation(), diag::note_previous_access_declaration)
55  << PrevMemberDecl << PrevMemberDecl->getAccess();
56 
57  MemberDecl->setAccess(LexicalAS);
58  return true;
59  }
60 
61  MemberDecl->setAccess(PrevMemberDecl->getAccess());
62  return false;
63 }
64 
66  DeclContext *DC = D->getDeclContext();
67 
68  // This can only happen at top: enum decls only "publish" their
69  // immediate members.
70  if (isa<EnumDecl>(DC))
71  DC = cast<EnumDecl>(DC)->getDeclContext();
72 
73  CXXRecordDecl *DeclaringClass = cast<CXXRecordDecl>(DC);
74  while (DeclaringClass->isAnonymousStructOrUnion())
75  DeclaringClass = cast<CXXRecordDecl>(DeclaringClass->getDeclContext());
76  return DeclaringClass;
77 }
78 
79 namespace {
80 struct EffectiveContext {
81  EffectiveContext() : Inner(nullptr), Dependent(false) {}
82 
83  explicit EffectiveContext(DeclContext *DC)
84  : Inner(DC),
85  Dependent(DC->isDependentContext()) {
86 
87  // C++11 [class.access.nest]p1:
88  // A nested class is a member and as such has the same access
89  // rights as any other member.
90  // C++11 [class.access]p2:
91  // A member of a class can also access all the names to which
92  // the class has access. A local class of a member function
93  // may access the same names that the member function itself
94  // may access.
95  // This almost implies that the privileges of nesting are transitive.
96  // Technically it says nothing about the local classes of non-member
97  // functions (which can gain privileges through friendship), but we
98  // take that as an oversight.
99  while (true) {
100  // We want to add canonical declarations to the EC lists for
101  // simplicity of checking, but we need to walk up through the
102  // actual current DC chain. Otherwise, something like a local
103  // extern or friend which happens to be the canonical
104  // declaration will really mess us up.
105 
106  if (isa<CXXRecordDecl>(DC)) {
107  CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
108  Records.push_back(Record->getCanonicalDecl());
109  DC = Record->getDeclContext();
110  } else if (isa<FunctionDecl>(DC)) {
111  FunctionDecl *Function = cast<FunctionDecl>(DC);
112  Functions.push_back(Function->getCanonicalDecl());
113  if (Function->getFriendObjectKind())
114  DC = Function->getLexicalDeclContext();
115  else
116  DC = Function->getDeclContext();
117  } else if (DC->isFileContext()) {
118  break;
119  } else {
120  DC = DC->getParent();
121  }
122  }
123  }
124 
125  bool isDependent() const { return Dependent; }
126 
127  bool includesClass(const CXXRecordDecl *R) const {
128  R = R->getCanonicalDecl();
129  return std::find(Records.begin(), Records.end(), R)
130  != Records.end();
131  }
132 
133  /// Retrieves the innermost "useful" context. Can be null if we're
134  /// doing access-control without privileges.
135  DeclContext *getInnerContext() const {
136  return Inner;
137  }
138 
139  typedef SmallVectorImpl<CXXRecordDecl*>::const_iterator record_iterator;
140 
141  DeclContext *Inner;
144  bool Dependent;
145 };
146 
147 /// Like sema::AccessedEntity, but kindly lets us scribble all over
148 /// it.
149 struct AccessTarget : public AccessedEntity {
150  AccessTarget(const AccessedEntity &Entity)
151  : AccessedEntity(Entity) {
152  initialize();
153  }
154 
155  AccessTarget(ASTContext &Context,
156  MemberNonce _,
157  CXXRecordDecl *NamingClass,
158  DeclAccessPair FoundDecl,
159  QualType BaseObjectType)
160  : AccessedEntity(Context.getDiagAllocator(), Member, NamingClass,
161  FoundDecl, BaseObjectType) {
162  initialize();
163  }
164 
165  AccessTarget(ASTContext &Context,
166  BaseNonce _,
167  CXXRecordDecl *BaseClass,
168  CXXRecordDecl *DerivedClass,
169  AccessSpecifier Access)
170  : AccessedEntity(Context.getDiagAllocator(), Base, BaseClass, DerivedClass,
171  Access) {
172  initialize();
173  }
174 
175  bool isInstanceMember() const {
176  return (isMemberAccess() && getTargetDecl()->isCXXInstanceMember());
177  }
178 
179  bool hasInstanceContext() const {
180  return HasInstanceContext;
181  }
182 
183  class SavedInstanceContext {
184  public:
185  SavedInstanceContext(SavedInstanceContext &&S)
186  : Target(S.Target), Has(S.Has) {
187  S.Target = nullptr;
188  }
189  ~SavedInstanceContext() {
190  if (Target)
191  Target->HasInstanceContext = Has;
192  }
193 
194  private:
195  friend struct AccessTarget;
196  explicit SavedInstanceContext(AccessTarget &Target)
197  : Target(&Target), Has(Target.HasInstanceContext) {}
198  AccessTarget *Target;
199  bool Has;
200  };
201 
202  SavedInstanceContext saveInstanceContext() {
203  return SavedInstanceContext(*this);
204  }
205 
206  void suppressInstanceContext() {
207  HasInstanceContext = false;
208  }
209 
210  const CXXRecordDecl *resolveInstanceContext(Sema &S) const {
211  assert(HasInstanceContext);
212  if (CalculatedInstanceContext)
213  return InstanceContext;
214 
215  CalculatedInstanceContext = true;
216  DeclContext *IC = S.computeDeclContext(getBaseObjectType());
217  InstanceContext = (IC ? cast<CXXRecordDecl>(IC)->getCanonicalDecl()
218  : nullptr);
219  return InstanceContext;
220  }
221 
222  const CXXRecordDecl *getDeclaringClass() const {
223  return DeclaringClass;
224  }
225 
226  /// The "effective" naming class is the canonical non-anonymous
227  /// class containing the actual naming class.
228  const CXXRecordDecl *getEffectiveNamingClass() const {
229  const CXXRecordDecl *namingClass = getNamingClass();
230  while (namingClass->isAnonymousStructOrUnion())
231  namingClass = cast<CXXRecordDecl>(namingClass->getParent());
232  return namingClass->getCanonicalDecl();
233  }
234 
235 private:
236  void initialize() {
237  HasInstanceContext = (isMemberAccess() &&
238  !getBaseObjectType().isNull() &&
239  getTargetDecl()->isCXXInstanceMember());
240  CalculatedInstanceContext = false;
241  InstanceContext = nullptr;
242 
243  if (isMemberAccess())
244  DeclaringClass = FindDeclaringClass(getTargetDecl());
245  else
246  DeclaringClass = getBaseClass();
247  DeclaringClass = DeclaringClass->getCanonicalDecl();
248  }
249 
250  bool HasInstanceContext : 1;
251  mutable bool CalculatedInstanceContext : 1;
252  mutable const CXXRecordDecl *InstanceContext;
253  const CXXRecordDecl *DeclaringClass;
254 };
255 
256 }
257 
258 /// Checks whether one class might instantiate to the other.
259 static bool MightInstantiateTo(const CXXRecordDecl *From,
260  const CXXRecordDecl *To) {
261  // Declaration names are always preserved by instantiation.
262  if (From->getDeclName() != To->getDeclName())
263  return false;
264 
265  const DeclContext *FromDC = From->getDeclContext()->getPrimaryContext();
266  const DeclContext *ToDC = To->getDeclContext()->getPrimaryContext();
267  if (FromDC == ToDC) return true;
268  if (FromDC->isFileContext() || ToDC->isFileContext()) return false;
269 
270  // Be conservative.
271  return true;
272 }
273 
274 /// Checks whether one class is derived from another, inclusively.
275 /// Properly indicates when it couldn't be determined due to
276 /// dependence.
277 ///
278 /// This should probably be donated to AST or at least Sema.
280  const CXXRecordDecl *Target) {
281  assert(Derived->getCanonicalDecl() == Derived);
282  assert(Target->getCanonicalDecl() == Target);
283 
284  if (Derived == Target) return AR_accessible;
285 
286  bool CheckDependent = Derived->isDependentContext();
287  if (CheckDependent && MightInstantiateTo(Derived, Target))
288  return AR_dependent;
289 
290  AccessResult OnFailure = AR_inaccessible;
291  SmallVector<const CXXRecordDecl*, 8> Queue; // actually a stack
292 
293  while (true) {
294  if (Derived->isDependentContext() && !Derived->hasDefinition() &&
295  !Derived->isLambda())
296  return AR_dependent;
297 
298  for (const auto &I : Derived->bases()) {
299  const CXXRecordDecl *RD;
300 
301  QualType T = I.getType();
302  if (const RecordType *RT = T->getAs<RecordType>()) {
303  RD = cast<CXXRecordDecl>(RT->getDecl());
304  } else if (const InjectedClassNameType *IT
305  = T->getAs<InjectedClassNameType>()) {
306  RD = IT->getDecl();
307  } else {
308  assert(T->isDependentType() && "non-dependent base wasn't a record?");
309  OnFailure = AR_dependent;
310  continue;
311  }
312 
313  RD = RD->getCanonicalDecl();
314  if (RD == Target) return AR_accessible;
315  if (CheckDependent && MightInstantiateTo(RD, Target))
316  OnFailure = AR_dependent;
317 
318  Queue.push_back(RD);
319  }
320 
321  if (Queue.empty()) break;
322 
323  Derived = Queue.pop_back_val();
324  }
325 
326  return OnFailure;
327 }
328 
329 
330 static bool MightInstantiateTo(Sema &S, DeclContext *Context,
331  DeclContext *Friend) {
332  if (Friend == Context)
333  return true;
334 
335  assert(!Friend->isDependentContext() &&
336  "can't handle friends with dependent contexts here");
337 
338  if (!Context->isDependentContext())
339  return false;
340 
341  if (Friend->isFileContext())
342  return false;
343 
344  // TODO: this is very conservative
345  return true;
346 }
347 
348 // Asks whether the type in 'context' can ever instantiate to the type
349 // in 'friend'.
350 static bool MightInstantiateTo(Sema &S, CanQualType Context, CanQualType Friend) {
351  if (Friend == Context)
352  return true;
353 
354  if (!Friend->isDependentType() && !Context->isDependentType())
355  return false;
356 
357  // TODO: this is very conservative.
358  return true;
359 }
360 
361 static bool MightInstantiateTo(Sema &S,
362  FunctionDecl *Context,
363  FunctionDecl *Friend) {
364  if (Context->getDeclName() != Friend->getDeclName())
365  return false;
366 
367  if (!MightInstantiateTo(S,
368  Context->getDeclContext(),
369  Friend->getDeclContext()))
370  return false;
371 
373  = S.Context.getCanonicalType(Friend->getType())
374  ->getAs<FunctionProtoType>();
376  = S.Context.getCanonicalType(Context->getType())
377  ->getAs<FunctionProtoType>();
378 
379  // There isn't any way that I know of to add qualifiers
380  // during instantiation.
381  if (FriendTy.getQualifiers() != ContextTy.getQualifiers())
382  return false;
383 
384  if (FriendTy->getNumParams() != ContextTy->getNumParams())
385  return false;
386 
387  if (!MightInstantiateTo(S, ContextTy->getReturnType(),
388  FriendTy->getReturnType()))
389  return false;
390 
391  for (unsigned I = 0, E = FriendTy->getNumParams(); I != E; ++I)
392  if (!MightInstantiateTo(S, ContextTy->getParamType(I),
393  FriendTy->getParamType(I)))
394  return false;
395 
396  return true;
397 }
398 
399 static bool MightInstantiateTo(Sema &S,
400  FunctionTemplateDecl *Context,
401  FunctionTemplateDecl *Friend) {
402  return MightInstantiateTo(S,
403  Context->getTemplatedDecl(),
404  Friend->getTemplatedDecl());
405 }
406 
408  const EffectiveContext &EC,
409  const CXXRecordDecl *Friend) {
410  if (EC.includesClass(Friend))
411  return AR_accessible;
412 
413  if (EC.isDependent()) {
414  for (const CXXRecordDecl *Context : EC.Records) {
415  if (MightInstantiateTo(Context, Friend))
416  return AR_dependent;
417  }
418  }
419 
420  return AR_inaccessible;
421 }
422 
424  const EffectiveContext &EC,
425  CanQualType Friend) {
426  if (const RecordType *RT = Friend->getAs<RecordType>())
427  return MatchesFriend(S, EC, cast<CXXRecordDecl>(RT->getDecl()));
428 
429  // TODO: we can do better than this
430  if (Friend->isDependentType())
431  return AR_dependent;
432 
433  return AR_inaccessible;
434 }
435 
436 /// Determines whether the given friend class template matches
437 /// anything in the effective context.
439  const EffectiveContext &EC,
440  ClassTemplateDecl *Friend) {
441  AccessResult OnFailure = AR_inaccessible;
442 
443  // Check whether the friend is the template of a class in the
444  // context chain.
446  I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {
447  CXXRecordDecl *Record = *I;
448 
449  // Figure out whether the current class has a template:
450  ClassTemplateDecl *CTD;
451 
452  // A specialization of the template...
453  if (isa<ClassTemplateSpecializationDecl>(Record)) {
454  CTD = cast<ClassTemplateSpecializationDecl>(Record)
455  ->getSpecializedTemplate();
456 
457  // ... or the template pattern itself.
458  } else {
459  CTD = Record->getDescribedClassTemplate();
460  if (!CTD) continue;
461  }
462 
463  // It's a match.
464  if (Friend == CTD->getCanonicalDecl())
465  return AR_accessible;
466 
467  // If the context isn't dependent, it can't be a dependent match.
468  if (!EC.isDependent())
469  continue;
470 
471  // If the template names don't match, it can't be a dependent
472  // match.
473  if (CTD->getDeclName() != Friend->getDeclName())
474  continue;
475 
476  // If the class's context can't instantiate to the friend's
477  // context, it can't be a dependent match.
478  if (!MightInstantiateTo(S, CTD->getDeclContext(),
479  Friend->getDeclContext()))
480  continue;
481 
482  // Otherwise, it's a dependent match.
483  OnFailure = AR_dependent;
484  }
485 
486  return OnFailure;
487 }
488 
489 /// Determines whether the given friend function matches anything in
490 /// the effective context.
492  const EffectiveContext &EC,
493  FunctionDecl *Friend) {
494  AccessResult OnFailure = AR_inaccessible;
495 
497  I = EC.Functions.begin(), E = EC.Functions.end(); I != E; ++I) {
498  if (Friend == *I)
499  return AR_accessible;
500 
501  if (EC.isDependent() && MightInstantiateTo(S, *I, Friend))
502  OnFailure = AR_dependent;
503  }
504 
505  return OnFailure;
506 }
507 
508 /// Determines whether the given friend function template matches
509 /// anything in the effective context.
511  const EffectiveContext &EC,
512  FunctionTemplateDecl *Friend) {
513  if (EC.Functions.empty()) return AR_inaccessible;
514 
515  AccessResult OnFailure = AR_inaccessible;
516 
518  I = EC.Functions.begin(), E = EC.Functions.end(); I != E; ++I) {
519 
520  FunctionTemplateDecl *FTD = (*I)->getPrimaryTemplate();
521  if (!FTD)
522  FTD = (*I)->getDescribedFunctionTemplate();
523  if (!FTD)
524  continue;
525 
526  FTD = FTD->getCanonicalDecl();
527 
528  if (Friend == FTD)
529  return AR_accessible;
530 
531  if (EC.isDependent() && MightInstantiateTo(S, FTD, Friend))
532  OnFailure = AR_dependent;
533  }
534 
535  return OnFailure;
536 }
537 
538 /// Determines whether the given friend declaration matches anything
539 /// in the effective context.
541  const EffectiveContext &EC,
542  FriendDecl *FriendD) {
543  // Whitelist accesses if there's an invalid or unsupported friend
544  // declaration.
545  if (FriendD->isInvalidDecl() || FriendD->isUnsupportedFriend())
546  return AR_accessible;
547 
548  if (TypeSourceInfo *T = FriendD->getFriendType())
549  return MatchesFriend(S, EC, T->getType()->getCanonicalTypeUnqualified());
550 
551  NamedDecl *Friend
552  = cast<NamedDecl>(FriendD->getFriendDecl()->getCanonicalDecl());
553 
554  // FIXME: declarations with dependent or templated scope.
555 
556  if (isa<ClassTemplateDecl>(Friend))
557  return MatchesFriend(S, EC, cast<ClassTemplateDecl>(Friend));
558 
559  if (isa<FunctionTemplateDecl>(Friend))
560  return MatchesFriend(S, EC, cast<FunctionTemplateDecl>(Friend));
561 
562  if (isa<CXXRecordDecl>(Friend))
563  return MatchesFriend(S, EC, cast<CXXRecordDecl>(Friend));
564 
565  assert(isa<FunctionDecl>(Friend) && "unknown friend decl kind");
566  return MatchesFriend(S, EC, cast<FunctionDecl>(Friend));
567 }
568 
570  const EffectiveContext &EC,
571  const CXXRecordDecl *Class) {
572  AccessResult OnFailure = AR_inaccessible;
573 
574  // Okay, check friends.
575  for (auto *Friend : Class->friends()) {
576  switch (MatchesFriend(S, EC, Friend)) {
577  case AR_accessible:
578  return AR_accessible;
579 
580  case AR_inaccessible:
581  continue;
582 
583  case AR_dependent:
584  OnFailure = AR_dependent;
585  break;
586  }
587  }
588 
589  // That's it, give up.
590  return OnFailure;
591 }
592 
593 namespace {
594 
595 /// A helper class for checking for a friend which will grant access
596 /// to a protected instance member.
597 struct ProtectedFriendContext {
598  Sema &S;
599  const EffectiveContext &EC;
600  const CXXRecordDecl *NamingClass;
601  bool CheckDependent;
602  bool EverDependent;
603 
604  /// The path down to the current base class.
606 
607  ProtectedFriendContext(Sema &S, const EffectiveContext &EC,
608  const CXXRecordDecl *InstanceContext,
609  const CXXRecordDecl *NamingClass)
610  : S(S), EC(EC), NamingClass(NamingClass),
611  CheckDependent(InstanceContext->isDependentContext() ||
612  NamingClass->isDependentContext()),
613  EverDependent(false) {}
614 
615  /// Check classes in the current path for friendship, starting at
616  /// the given index.
617  bool checkFriendshipAlongPath(unsigned I) {
618  assert(I < CurPath.size());
619  for (unsigned E = CurPath.size(); I != E; ++I) {
620  switch (GetFriendKind(S, EC, CurPath[I])) {
621  case AR_accessible: return true;
622  case AR_inaccessible: continue;
623  case AR_dependent: EverDependent = true; continue;
624  }
625  }
626  return false;
627  }
628 
629  /// Perform a search starting at the given class.
630  ///
631  /// PrivateDepth is the index of the last (least derived) class
632  /// along the current path such that a notional public member of
633  /// the final class in the path would have access in that class.
634  bool findFriendship(const CXXRecordDecl *Cur, unsigned PrivateDepth) {
635  // If we ever reach the naming class, check the current path for
636  // friendship. We can also stop recursing because we obviously
637  // won't find the naming class there again.
638  if (Cur == NamingClass)
639  return checkFriendshipAlongPath(PrivateDepth);
640 
641  if (CheckDependent && MightInstantiateTo(Cur, NamingClass))
642  EverDependent = true;
643 
644  // Recurse into the base classes.
645  for (const auto &I : Cur->bases()) {
646  // If this is private inheritance, then a public member of the
647  // base will not have any access in classes derived from Cur.
648  unsigned BasePrivateDepth = PrivateDepth;
649  if (I.getAccessSpecifier() == AS_private)
650  BasePrivateDepth = CurPath.size() - 1;
651 
652  const CXXRecordDecl *RD;
653 
654  QualType T = I.getType();
655  if (const RecordType *RT = T->getAs<RecordType>()) {
656  RD = cast<CXXRecordDecl>(RT->getDecl());
657  } else if (const InjectedClassNameType *IT
658  = T->getAs<InjectedClassNameType>()) {
659  RD = IT->getDecl();
660  } else {
661  assert(T->isDependentType() && "non-dependent base wasn't a record?");
662  EverDependent = true;
663  continue;
664  }
665 
666  // Recurse. We don't need to clean up if this returns true.
667  CurPath.push_back(RD);
668  if (findFriendship(RD->getCanonicalDecl(), BasePrivateDepth))
669  return true;
670  CurPath.pop_back();
671  }
672 
673  return false;
674  }
675 
676  bool findFriendship(const CXXRecordDecl *Cur) {
677  assert(CurPath.empty());
678  CurPath.push_back(Cur);
679  return findFriendship(Cur, 0);
680  }
681 };
682 }
683 
684 /// Search for a class P that EC is a friend of, under the constraint
685 /// InstanceContext <= P
686 /// if InstanceContext exists, or else
687 /// NamingClass <= P
688 /// and with the additional restriction that a protected member of
689 /// NamingClass would have some natural access in P, which implicitly
690 /// imposes the constraint that P <= NamingClass.
691 ///
692 /// This isn't quite the condition laid out in the standard.
693 /// Instead of saying that a notional protected member of NamingClass
694 /// would have to have some natural access in P, it says the actual
695 /// target has to have some natural access in P, which opens up the
696 /// possibility that the target (which is not necessarily a member
697 /// of NamingClass) might be more accessible along some path not
698 /// passing through it. That's really a bad idea, though, because it
699 /// introduces two problems:
700 /// - Most importantly, it breaks encapsulation because you can
701 /// access a forbidden base class's members by directly subclassing
702 /// it elsewhere.
703 /// - It also makes access substantially harder to compute because it
704 /// breaks the hill-climbing algorithm: knowing that the target is
705 /// accessible in some base class would no longer let you change
706 /// the question solely to whether the base class is accessible,
707 /// because the original target might have been more accessible
708 /// because of crazy subclassing.
709 /// So we don't implement that.
710 static AccessResult GetProtectedFriendKind(Sema &S, const EffectiveContext &EC,
711  const CXXRecordDecl *InstanceContext,
712  const CXXRecordDecl *NamingClass) {
713  assert(InstanceContext == nullptr ||
714  InstanceContext->getCanonicalDecl() == InstanceContext);
715  assert(NamingClass->getCanonicalDecl() == NamingClass);
716 
717  // If we don't have an instance context, our constraints give us
718  // that NamingClass <= P <= NamingClass, i.e. P == NamingClass.
719  // This is just the usual friendship check.
720  if (!InstanceContext) return GetFriendKind(S, EC, NamingClass);
721 
722  ProtectedFriendContext PRC(S, EC, InstanceContext, NamingClass);
723  if (PRC.findFriendship(InstanceContext)) return AR_accessible;
724  if (PRC.EverDependent) return AR_dependent;
725  return AR_inaccessible;
726 }
727 
729  const EffectiveContext &EC,
730  const CXXRecordDecl *NamingClass,
731  AccessSpecifier Access,
732  const AccessTarget &Target) {
733  assert(NamingClass->getCanonicalDecl() == NamingClass &&
734  "declaration should be canonicalized before being passed here");
735 
736  if (Access == AS_public) return AR_accessible;
737  assert(Access == AS_private || Access == AS_protected);
738 
739  AccessResult OnFailure = AR_inaccessible;
740 
741  for (EffectiveContext::record_iterator
742  I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {
743  // All the declarations in EC have been canonicalized, so pointer
744  // equality from this point on will work fine.
745  const CXXRecordDecl *ECRecord = *I;
746 
747  // [B2] and [M2]
748  if (Access == AS_private) {
749  if (ECRecord == NamingClass)
750  return AR_accessible;
751 
752  if (EC.isDependent() && MightInstantiateTo(ECRecord, NamingClass))
753  OnFailure = AR_dependent;
754 
755  // [B3] and [M3]
756  } else {
757  assert(Access == AS_protected);
758  switch (IsDerivedFromInclusive(ECRecord, NamingClass)) {
759  case AR_accessible: break;
760  case AR_inaccessible: continue;
761  case AR_dependent: OnFailure = AR_dependent; continue;
762  }
763 
764  // C++ [class.protected]p1:
765  // An additional access check beyond those described earlier in
766  // [class.access] is applied when a non-static data member or
767  // non-static member function is a protected member of its naming
768  // class. As described earlier, access to a protected member is
769  // granted because the reference occurs in a friend or member of
770  // some class C. If the access is to form a pointer to member,
771  // the nested-name-specifier shall name C or a class derived from
772  // C. All other accesses involve a (possibly implicit) object
773  // expression. In this case, the class of the object expression
774  // shall be C or a class derived from C.
775  //
776  // We interpret this as a restriction on [M3].
777 
778  // In this part of the code, 'C' is just our context class ECRecord.
779 
780  // These rules are different if we don't have an instance context.
781  if (!Target.hasInstanceContext()) {
782  // If it's not an instance member, these restrictions don't apply.
783  if (!Target.isInstanceMember()) return AR_accessible;
784 
785  // If it's an instance member, use the pointer-to-member rule
786  // that the naming class has to be derived from the effective
787  // context.
788 
789  // Emulate a MSVC bug where the creation of pointer-to-member
790  // to protected member of base class is allowed but only from
791  // static member functions.
792  if (S.getLangOpts().MSVCCompat && !EC.Functions.empty())
793  if (CXXMethodDecl* MD = dyn_cast<CXXMethodDecl>(EC.Functions.front()))
794  if (MD->isStatic()) return AR_accessible;
795 
796  // Despite the standard's confident wording, there is a case
797  // where you can have an instance member that's neither in a
798  // pointer-to-member expression nor in a member access: when
799  // it names a field in an unevaluated context that can't be an
800  // implicit member. Pending clarification, we just apply the
801  // same naming-class restriction here.
802  // FIXME: we're probably not correctly adding the
803  // protected-member restriction when we retroactively convert
804  // an expression to being evaluated.
805 
806  // We know that ECRecord derives from NamingClass. The
807  // restriction says to check whether NamingClass derives from
808  // ECRecord, but that's not really necessary: two distinct
809  // classes can't be recursively derived from each other. So
810  // along this path, we just need to check whether the classes
811  // are equal.
812  if (NamingClass == ECRecord) return AR_accessible;
813 
814  // Otherwise, this context class tells us nothing; on to the next.
815  continue;
816  }
817 
818  assert(Target.isInstanceMember());
819 
820  const CXXRecordDecl *InstanceContext = Target.resolveInstanceContext(S);
821  if (!InstanceContext) {
822  OnFailure = AR_dependent;
823  continue;
824  }
825 
826  switch (IsDerivedFromInclusive(InstanceContext, ECRecord)) {
827  case AR_accessible: return AR_accessible;
828  case AR_inaccessible: continue;
829  case AR_dependent: OnFailure = AR_dependent; continue;
830  }
831  }
832  }
833 
834  // [M3] and [B3] say that, if the target is protected in N, we grant
835  // access if the access occurs in a friend or member of some class P
836  // that's a subclass of N and where the target has some natural
837  // access in P. The 'member' aspect is easy to handle because P
838  // would necessarily be one of the effective-context records, and we
839  // address that above. The 'friend' aspect is completely ridiculous
840  // to implement because there are no restrictions at all on P
841  // *unless* the [class.protected] restriction applies. If it does,
842  // however, we should ignore whether the naming class is a friend,
843  // and instead rely on whether any potential P is a friend.
844  if (Access == AS_protected && Target.isInstanceMember()) {
845  // Compute the instance context if possible.
846  const CXXRecordDecl *InstanceContext = nullptr;
847  if (Target.hasInstanceContext()) {
848  InstanceContext = Target.resolveInstanceContext(S);
849  if (!InstanceContext) return AR_dependent;
850  }
851 
852  switch (GetProtectedFriendKind(S, EC, InstanceContext, NamingClass)) {
853  case AR_accessible: return AR_accessible;
854  case AR_inaccessible: return OnFailure;
855  case AR_dependent: return AR_dependent;
856  }
857  llvm_unreachable("impossible friendship kind");
858  }
859 
860  switch (GetFriendKind(S, EC, NamingClass)) {
861  case AR_accessible: return AR_accessible;
862  case AR_inaccessible: return OnFailure;
863  case AR_dependent: return AR_dependent;
864  }
865 
866  // Silence bogus warnings
867  llvm_unreachable("impossible friendship kind");
868 }
869 
870 /// Finds the best path from the naming class to the declaring class,
871 /// taking friend declarations into account.
872 ///
873 /// C++0x [class.access.base]p5:
874 /// A member m is accessible at the point R when named in class N if
875 /// [M1] m as a member of N is public, or
876 /// [M2] m as a member of N is private, and R occurs in a member or
877 /// friend of class N, or
878 /// [M3] m as a member of N is protected, and R occurs in a member or
879 /// friend of class N, or in a member or friend of a class P
880 /// derived from N, where m as a member of P is public, private,
881 /// or protected, or
882 /// [M4] there exists a base class B of N that is accessible at R, and
883 /// m is accessible at R when named in class B.
884 ///
885 /// C++0x [class.access.base]p4:
886 /// A base class B of N is accessible at R, if
887 /// [B1] an invented public member of B would be a public member of N, or
888 /// [B2] R occurs in a member or friend of class N, and an invented public
889 /// member of B would be a private or protected member of N, or
890 /// [B3] R occurs in a member or friend of a class P derived from N, and an
891 /// invented public member of B would be a private or protected member
892 /// of P, or
893 /// [B4] there exists a class S such that B is a base class of S accessible
894 /// at R and S is a base class of N accessible at R.
895 ///
896 /// Along a single inheritance path we can restate both of these
897 /// iteratively:
898 ///
899 /// First, we note that M1-4 are equivalent to B1-4 if the member is
900 /// treated as a notional base of its declaring class with inheritance
901 /// access equivalent to the member's access. Therefore we need only
902 /// ask whether a class B is accessible from a class N in context R.
903 ///
904 /// Let B_1 .. B_n be the inheritance path in question (i.e. where
905 /// B_1 = N, B_n = B, and for all i, B_{i+1} is a direct base class of
906 /// B_i). For i in 1..n, we will calculate ACAB(i), the access to the
907 /// closest accessible base in the path:
908 /// Access(a, b) = (* access on the base specifier from a to b *)
909 /// Merge(a, forbidden) = forbidden
910 /// Merge(a, private) = forbidden
911 /// Merge(a, b) = min(a,b)
912 /// Accessible(c, forbidden) = false
913 /// Accessible(c, private) = (R is c) || IsFriend(c, R)
914 /// Accessible(c, protected) = (R derived from c) || IsFriend(c, R)
915 /// Accessible(c, public) = true
916 /// ACAB(n) = public
917 /// ACAB(i) =
918 /// let AccessToBase = Merge(Access(B_i, B_{i+1}), ACAB(i+1)) in
919 /// if Accessible(B_i, AccessToBase) then public else AccessToBase
920 ///
921 /// B is an accessible base of N at R iff ACAB(1) = public.
922 ///
923 /// \param FinalAccess the access of the "final step", or AS_public if
924 /// there is no final step.
925 /// \return null if friendship is dependent
927  const EffectiveContext &EC,
928  AccessTarget &Target,
929  AccessSpecifier FinalAccess,
930  CXXBasePaths &Paths) {
931  // Derive the paths to the desired base.
932  const CXXRecordDecl *Derived = Target.getNamingClass();
933  const CXXRecordDecl *Base = Target.getDeclaringClass();
934 
935  // FIXME: fail correctly when there are dependent paths.
936  bool isDerived = Derived->isDerivedFrom(const_cast<CXXRecordDecl*>(Base),
937  Paths);
938  assert(isDerived && "derived class not actually derived from base");
939  (void) isDerived;
940 
941  CXXBasePath *BestPath = nullptr;
942 
943  assert(FinalAccess != AS_none && "forbidden access after declaring class");
944 
945  bool AnyDependent = false;
946 
947  // Derive the friend-modified access along each path.
948  for (CXXBasePaths::paths_iterator PI = Paths.begin(), PE = Paths.end();
949  PI != PE; ++PI) {
950  AccessTarget::SavedInstanceContext _ = Target.saveInstanceContext();
951 
952  // Walk through the path backwards.
953  AccessSpecifier PathAccess = FinalAccess;
954  CXXBasePath::iterator I = PI->end(), E = PI->begin();
955  while (I != E) {
956  --I;
957 
958  assert(PathAccess != AS_none);
959 
960  // If the declaration is a private member of a base class, there
961  // is no level of friendship in derived classes that can make it
962  // accessible.
963  if (PathAccess == AS_private) {
964  PathAccess = AS_none;
965  break;
966  }
967 
968  const CXXRecordDecl *NC = I->Class->getCanonicalDecl();
969 
970  AccessSpecifier BaseAccess = I->Base->getAccessSpecifier();
971  PathAccess = std::max(PathAccess, BaseAccess);
972 
973  switch (HasAccess(S, EC, NC, PathAccess, Target)) {
974  case AR_inaccessible: break;
975  case AR_accessible:
976  PathAccess = AS_public;
977 
978  // Future tests are not against members and so do not have
979  // instance context.
980  Target.suppressInstanceContext();
981  break;
982  case AR_dependent:
983  AnyDependent = true;
984  goto Next;
985  }
986  }
987 
988  // Note that we modify the path's Access field to the
989  // friend-modified access.
990  if (BestPath == nullptr || PathAccess < BestPath->Access) {
991  BestPath = &*PI;
992  BestPath->Access = PathAccess;
993 
994  // Short-circuit if we found a public path.
995  if (BestPath->Access == AS_public)
996  return BestPath;
997  }
998 
999  Next: ;
1000  }
1001 
1002  assert((!BestPath || BestPath->Access != AS_public) &&
1003  "fell out of loop with public path");
1004 
1005  // We didn't find a public path, but at least one path was subject
1006  // to dependent friendship, so delay the check.
1007  if (AnyDependent)
1008  return nullptr;
1009 
1010  return BestPath;
1011 }
1012 
1013 /// Given that an entity has protected natural access, check whether
1014 /// access might be denied because of the protected member access
1015 /// restriction.
1016 ///
1017 /// \return true if a note was emitted
1018 static bool TryDiagnoseProtectedAccess(Sema &S, const EffectiveContext &EC,
1019  AccessTarget &Target) {
1020  // Only applies to instance accesses.
1021  if (!Target.isInstanceMember())
1022  return false;
1023 
1024  assert(Target.isMemberAccess());
1025 
1026  const CXXRecordDecl *NamingClass = Target.getEffectiveNamingClass();
1027 
1028  for (EffectiveContext::record_iterator
1029  I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {
1030  const CXXRecordDecl *ECRecord = *I;
1031  switch (IsDerivedFromInclusive(ECRecord, NamingClass)) {
1032  case AR_accessible: break;
1033  case AR_inaccessible: continue;
1034  case AR_dependent: continue;
1035  }
1036 
1037  // The effective context is a subclass of the declaring class.
1038  // Check whether the [class.protected] restriction is limiting
1039  // access.
1040 
1041  // To get this exactly right, this might need to be checked more
1042  // holistically; it's not necessarily the case that gaining
1043  // access here would grant us access overall.
1044 
1045  NamedDecl *D = Target.getTargetDecl();
1046 
1047  // If we don't have an instance context, [class.protected] says the
1048  // naming class has to equal the context class.
1049  if (!Target.hasInstanceContext()) {
1050  // If it does, the restriction doesn't apply.
1051  if (NamingClass == ECRecord) continue;
1052 
1053  // TODO: it would be great to have a fixit here, since this is
1054  // such an obvious error.
1055  S.Diag(D->getLocation(), diag::note_access_protected_restricted_noobject)
1056  << S.Context.getTypeDeclType(ECRecord);
1057  return true;
1058  }
1059 
1060  const CXXRecordDecl *InstanceContext = Target.resolveInstanceContext(S);
1061  assert(InstanceContext && "diagnosing dependent access");
1062 
1063  switch (IsDerivedFromInclusive(InstanceContext, ECRecord)) {
1064  case AR_accessible: continue;
1065  case AR_dependent: continue;
1066  case AR_inaccessible:
1067  break;
1068  }
1069 
1070  // Okay, the restriction seems to be what's limiting us.
1071 
1072  // Use a special diagnostic for constructors and destructors.
1073  if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D) ||
1074  (isa<FunctionTemplateDecl>(D) &&
1075  isa<CXXConstructorDecl>(
1076  cast<FunctionTemplateDecl>(D)->getTemplatedDecl()))) {
1077  return S.Diag(D->getLocation(),
1078  diag::note_access_protected_restricted_ctordtor)
1079  << isa<CXXDestructorDecl>(D->getAsFunction());
1080  }
1081 
1082  // Otherwise, use the generic diagnostic.
1083  return S.Diag(D->getLocation(),
1084  diag::note_access_protected_restricted_object)
1085  << S.Context.getTypeDeclType(ECRecord);
1086  }
1087 
1088  return false;
1089 }
1090 
1091 /// We are unable to access a given declaration due to its direct
1092 /// access control; diagnose that.
1094  const EffectiveContext &EC,
1095  AccessTarget &entity) {
1096  assert(entity.isMemberAccess());
1097  NamedDecl *D = entity.getTargetDecl();
1098 
1099  if (D->getAccess() == AS_protected &&
1100  TryDiagnoseProtectedAccess(S, EC, entity))
1101  return;
1102 
1103  // Find an original declaration.
1104  while (D->isOutOfLine()) {
1105  NamedDecl *PrevDecl = nullptr;
1106  if (VarDecl *VD = dyn_cast<VarDecl>(D))
1107  PrevDecl = VD->getPreviousDecl();
1108  else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
1109  PrevDecl = FD->getPreviousDecl();
1110  else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(D))
1111  PrevDecl = TND->getPreviousDecl();
1112  else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1113  if (isa<RecordDecl>(D) && cast<RecordDecl>(D)->isInjectedClassName())
1114  break;
1115  PrevDecl = TD->getPreviousDecl();
1116  }
1117  if (!PrevDecl) break;
1118  D = PrevDecl;
1119  }
1120 
1121  CXXRecordDecl *DeclaringClass = FindDeclaringClass(D);
1122  Decl *ImmediateChild;
1123  if (D->getDeclContext() == DeclaringClass)
1124  ImmediateChild = D;
1125  else {
1126  DeclContext *DC = D->getDeclContext();
1127  while (DC->getParent() != DeclaringClass)
1128  DC = DC->getParent();
1129  ImmediateChild = cast<Decl>(DC);
1130  }
1131 
1132  // Check whether there's an AccessSpecDecl preceding this in the
1133  // chain of the DeclContext.
1134  bool isImplicit = true;
1135  for (const auto *I : DeclaringClass->decls()) {
1136  if (I == ImmediateChild) break;
1137  if (isa<AccessSpecDecl>(I)) {
1138  isImplicit = false;
1139  break;
1140  }
1141  }
1142 
1143  S.Diag(D->getLocation(), diag::note_access_natural)
1144  << (unsigned) (D->getAccess() == AS_protected)
1145  << isImplicit;
1146 }
1147 
1148 /// Diagnose the path which caused the given declaration or base class
1149 /// to become inaccessible.
1150 static void DiagnoseAccessPath(Sema &S,
1151  const EffectiveContext &EC,
1152  AccessTarget &entity) {
1153  // Save the instance context to preserve invariants.
1154  AccessTarget::SavedInstanceContext _ = entity.saveInstanceContext();
1155 
1156  // This basically repeats the main algorithm but keeps some more
1157  // information.
1158 
1159  // The natural access so far.
1160  AccessSpecifier accessSoFar = AS_public;
1161 
1162  // Check whether we have special rights to the declaring class.
1163  if (entity.isMemberAccess()) {
1164  NamedDecl *D = entity.getTargetDecl();
1165  accessSoFar = D->getAccess();
1166  const CXXRecordDecl *declaringClass = entity.getDeclaringClass();
1167 
1168  switch (HasAccess(S, EC, declaringClass, accessSoFar, entity)) {
1169  // If the declaration is accessible when named in its declaring
1170  // class, then we must be constrained by the path.
1171  case AR_accessible:
1172  accessSoFar = AS_public;
1173  entity.suppressInstanceContext();
1174  break;
1175 
1176  case AR_inaccessible:
1177  if (accessSoFar == AS_private ||
1178  declaringClass == entity.getEffectiveNamingClass())
1179  return diagnoseBadDirectAccess(S, EC, entity);
1180  break;
1181 
1182  case AR_dependent:
1183  llvm_unreachable("cannot diagnose dependent access");
1184  }
1185  }
1186 
1187  CXXBasePaths paths;
1188  CXXBasePath &path = *FindBestPath(S, EC, entity, accessSoFar, paths);
1189  assert(path.Access != AS_public);
1190 
1191  CXXBasePath::iterator i = path.end(), e = path.begin();
1192  CXXBasePath::iterator constrainingBase = i;
1193  while (i != e) {
1194  --i;
1195 
1196  assert(accessSoFar != AS_none && accessSoFar != AS_private);
1197 
1198  // Is the entity accessible when named in the deriving class, as
1199  // modified by the base specifier?
1200  const CXXRecordDecl *derivingClass = i->Class->getCanonicalDecl();
1201  const CXXBaseSpecifier *base = i->Base;
1202 
1203  // If the access to this base is worse than the access we have to
1204  // the declaration, remember it.
1205  AccessSpecifier baseAccess = base->getAccessSpecifier();
1206  if (baseAccess > accessSoFar) {
1207  constrainingBase = i;
1208  accessSoFar = baseAccess;
1209  }
1210 
1211  switch (HasAccess(S, EC, derivingClass, accessSoFar, entity)) {
1212  case AR_inaccessible: break;
1213  case AR_accessible:
1214  accessSoFar = AS_public;
1215  entity.suppressInstanceContext();
1216  constrainingBase = nullptr;
1217  break;
1218  case AR_dependent:
1219  llvm_unreachable("cannot diagnose dependent access");
1220  }
1221 
1222  // If this was private inheritance, but we don't have access to
1223  // the deriving class, we're done.
1224  if (accessSoFar == AS_private) {
1225  assert(baseAccess == AS_private);
1226  assert(constrainingBase == i);
1227  break;
1228  }
1229  }
1230 
1231  // If we don't have a constraining base, the access failure must be
1232  // due to the original declaration.
1233  if (constrainingBase == path.end())
1234  return diagnoseBadDirectAccess(S, EC, entity);
1235 
1236  // We're constrained by inheritance, but we want to say
1237  // "declared private here" if we're diagnosing a hierarchy
1238  // conversion and this is the final step.
1239  unsigned diagnostic;
1240  if (entity.isMemberAccess() ||
1241  constrainingBase + 1 != path.end()) {
1242  diagnostic = diag::note_access_constrained_by_path;
1243  } else {
1244  diagnostic = diag::note_access_natural;
1245  }
1246 
1247  const CXXBaseSpecifier *base = constrainingBase->Base;
1248 
1249  S.Diag(base->getSourceRange().getBegin(), diagnostic)
1250  << base->getSourceRange()
1251  << (base->getAccessSpecifier() == AS_protected)
1252  << (base->getAccessSpecifierAsWritten() == AS_none);
1253 
1254  if (entity.isMemberAccess())
1255  S.Diag(entity.getTargetDecl()->getLocation(),
1256  diag::note_member_declared_at);
1257 }
1258 
1260  const EffectiveContext &EC,
1261  AccessTarget &Entity) {
1262  const CXXRecordDecl *NamingClass = Entity.getNamingClass();
1263  const CXXRecordDecl *DeclaringClass = Entity.getDeclaringClass();
1264  NamedDecl *D = (Entity.isMemberAccess() ? Entity.getTargetDecl() : nullptr);
1265 
1266  S.Diag(Loc, Entity.getDiag())
1267  << (Entity.getAccess() == AS_protected)
1268  << (D ? D->getDeclName() : DeclarationName())
1269  << S.Context.getTypeDeclType(NamingClass)
1270  << S.Context.getTypeDeclType(DeclaringClass);
1271  DiagnoseAccessPath(S, EC, Entity);
1272 }
1273 
1274 /// MSVC has a bug where if during an using declaration name lookup,
1275 /// the declaration found is unaccessible (private) and that declaration
1276 /// was bring into scope via another using declaration whose target
1277 /// declaration is accessible (public) then no error is generated.
1278 /// Example:
1279 /// class A {
1280 /// public:
1281 /// int f();
1282 /// };
1283 /// class B : public A {
1284 /// private:
1285 /// using A::f;
1286 /// };
1287 /// class C : public B {
1288 /// private:
1289 /// using B::f;
1290 /// };
1291 ///
1292 /// Here, B::f is private so this should fail in Standard C++, but
1293 /// because B::f refers to A::f which is public MSVC accepts it.
1295  SourceLocation AccessLoc,
1296  AccessTarget &Entity) {
1297  if (UsingShadowDecl *Shadow =
1298  dyn_cast<UsingShadowDecl>(Entity.getTargetDecl())) {
1299  const NamedDecl *OrigDecl = Entity.getTargetDecl()->getUnderlyingDecl();
1300  if (Entity.getTargetDecl()->getAccess() == AS_private &&
1301  (OrigDecl->getAccess() == AS_public ||
1302  OrigDecl->getAccess() == AS_protected)) {
1303  S.Diag(AccessLoc, diag::ext_ms_using_declaration_inaccessible)
1304  << Shadow->getUsingDecl()->getQualifiedNameAsString()
1305  << OrigDecl->getQualifiedNameAsString();
1306  return true;
1307  }
1308  }
1309  return false;
1310 }
1311 
1312 /// Determines whether the accessed entity is accessible. Public members
1313 /// have been weeded out by this point.
1315  const EffectiveContext &EC,
1316  AccessTarget &Entity) {
1317  // Determine the actual naming class.
1318  const CXXRecordDecl *NamingClass = Entity.getEffectiveNamingClass();
1319 
1320  AccessSpecifier UnprivilegedAccess = Entity.getAccess();
1321  assert(UnprivilegedAccess != AS_public && "public access not weeded out");
1322 
1323  // Before we try to recalculate access paths, try to white-list
1324  // accesses which just trade in on the final step, i.e. accesses
1325  // which don't require [M4] or [B4]. These are by far the most
1326  // common forms of privileged access.
1327  if (UnprivilegedAccess != AS_none) {
1328  switch (HasAccess(S, EC, NamingClass, UnprivilegedAccess, Entity)) {
1329  case AR_dependent:
1330  // This is actually an interesting policy decision. We don't
1331  // *have* to delay immediately here: we can do the full access
1332  // calculation in the hope that friendship on some intermediate
1333  // class will make the declaration accessible non-dependently.
1334  // But that's not cheap, and odds are very good (note: assertion
1335  // made without data) that the friend declaration will determine
1336  // access.
1337  return AR_dependent;
1338 
1339  case AR_accessible: return AR_accessible;
1340  case AR_inaccessible: break;
1341  }
1342  }
1343 
1344  AccessTarget::SavedInstanceContext _ = Entity.saveInstanceContext();
1345 
1346  // We lower member accesses to base accesses by pretending that the
1347  // member is a base class of its declaring class.
1348  AccessSpecifier FinalAccess;
1349 
1350  if (Entity.isMemberAccess()) {
1351  // Determine if the declaration is accessible from EC when named
1352  // in its declaring class.
1353  NamedDecl *Target = Entity.getTargetDecl();
1354  const CXXRecordDecl *DeclaringClass = Entity.getDeclaringClass();
1355 
1356  FinalAccess = Target->getAccess();
1357  switch (HasAccess(S, EC, DeclaringClass, FinalAccess, Entity)) {
1358  case AR_accessible:
1359  // Target is accessible at EC when named in its declaring class.
1360  // We can now hill-climb and simply check whether the declaring
1361  // class is accessible as a base of the naming class. This is
1362  // equivalent to checking the access of a notional public
1363  // member with no instance context.
1364  FinalAccess = AS_public;
1365  Entity.suppressInstanceContext();
1366  break;
1367  case AR_inaccessible: break;
1368  case AR_dependent: return AR_dependent; // see above
1369  }
1370 
1371  if (DeclaringClass == NamingClass)
1372  return (FinalAccess == AS_public ? AR_accessible : AR_inaccessible);
1373  } else {
1374  FinalAccess = AS_public;
1375  }
1376 
1377  assert(Entity.getDeclaringClass() != NamingClass);
1378 
1379  // Append the declaration's access if applicable.
1380  CXXBasePaths Paths;
1381  CXXBasePath *Path = FindBestPath(S, EC, Entity, FinalAccess, Paths);
1382  if (!Path)
1383  return AR_dependent;
1384 
1385  assert(Path->Access <= UnprivilegedAccess &&
1386  "access along best path worse than direct?");
1387  if (Path->Access == AS_public)
1388  return AR_accessible;
1389  return AR_inaccessible;
1390 }
1391 
1393  const EffectiveContext &EC,
1394  SourceLocation Loc,
1395  const AccessTarget &Entity) {
1396  assert(EC.isDependent() && "delaying non-dependent access");
1397  DeclContext *DC = EC.getInnerContext();
1398  assert(DC->isDependentContext() && "delaying non-dependent access");
1400  Loc,
1401  Entity.isMemberAccess(),
1402  Entity.getAccess(),
1403  Entity.getTargetDecl(),
1404  Entity.getNamingClass(),
1405  Entity.getBaseObjectType(),
1406  Entity.getDiag());
1407 }
1408 
1409 /// Checks access to an entity from the given effective context.
1411  const EffectiveContext &EC,
1412  SourceLocation Loc,
1413  AccessTarget &Entity) {
1414  assert(Entity.getAccess() != AS_public && "called for public access!");
1415 
1416  switch (IsAccessible(S, EC, Entity)) {
1417  case AR_dependent:
1418  DelayDependentAccess(S, EC, Loc, Entity);
1419  return AR_dependent;
1420 
1421  case AR_inaccessible:
1422  if (S.getLangOpts().MSVCCompat &&
1423  IsMicrosoftUsingDeclarationAccessBug(S, Loc, Entity))
1424  return AR_accessible;
1425  if (!Entity.isQuiet())
1426  DiagnoseBadAccess(S, Loc, EC, Entity);
1427  return AR_inaccessible;
1428 
1429  case AR_accessible:
1430  return AR_accessible;
1431  }
1432 
1433  // silence unnecessary warning
1434  llvm_unreachable("invalid access result");
1435 }
1436 
1438  AccessTarget &Entity) {
1439  // If the access path is public, it's accessible everywhere.
1440  if (Entity.getAccess() == AS_public)
1441  return Sema::AR_accessible;
1442 
1443  // If we're currently parsing a declaration, we may need to delay
1444  // access control checking, because our effective context might be
1445  // different based on what the declaration comes out as.
1446  //
1447  // For example, we might be parsing a declaration with a scope
1448  // specifier, like this:
1449  // A::private_type A::foo() { ... }
1450  //
1451  // Or we might be parsing something that will turn out to be a friend:
1452  // void foo(A::private_type);
1453  // void B::foo(A::private_type);
1456  return Sema::AR_delayed;
1457  }
1458 
1459  EffectiveContext EC(S.CurContext);
1460  switch (CheckEffectiveAccess(S, EC, Loc, Entity)) {
1461  case AR_accessible: return Sema::AR_accessible;
1463  case AR_dependent: return Sema::AR_dependent;
1464  }
1465  llvm_unreachable("invalid access result");
1466 }
1467 
1469  // Access control for names used in the declarations of functions
1470  // and function templates should normally be evaluated in the context
1471  // of the declaration, just in case it's a friend of something.
1472  // However, this does not apply to local extern declarations.
1473 
1474  DeclContext *DC = D->getDeclContext();
1475  if (D->isLocalExternDecl()) {
1476  DC = D->getLexicalDeclContext();
1477  } else if (FunctionDecl *FN = dyn_cast<FunctionDecl>(D)) {
1478  DC = FN;
1479  } else if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) {
1480  DC = cast<DeclContext>(TD->getTemplatedDecl());
1481  }
1482 
1483  EffectiveContext EC(DC);
1484 
1485  AccessTarget Target(DD.getAccessData());
1486 
1487  if (CheckEffectiveAccess(*this, EC, DD.Loc, Target) == ::AR_inaccessible)
1488  DD.Triggered = true;
1489 }
1490 
1492  const MultiLevelTemplateArgumentList &TemplateArgs) {
1493  SourceLocation Loc = DD.getAccessLoc();
1494  AccessSpecifier Access = DD.getAccess();
1495 
1496  Decl *NamingD = FindInstantiatedDecl(Loc, DD.getAccessNamingClass(),
1497  TemplateArgs);
1498  if (!NamingD) return;
1499  Decl *TargetD = FindInstantiatedDecl(Loc, DD.getAccessTarget(),
1500  TemplateArgs);
1501  if (!TargetD) return;
1502 
1503  if (DD.isAccessToMember()) {
1504  CXXRecordDecl *NamingClass = cast<CXXRecordDecl>(NamingD);
1505  NamedDecl *TargetDecl = cast<NamedDecl>(TargetD);
1506  QualType BaseObjectType = DD.getAccessBaseObjectType();
1507  if (!BaseObjectType.isNull()) {
1508  BaseObjectType = SubstType(BaseObjectType, TemplateArgs, Loc,
1509  DeclarationName());
1510  if (BaseObjectType.isNull()) return;
1511  }
1512 
1513  AccessTarget Entity(Context,
1514  AccessTarget::Member,
1515  NamingClass,
1516  DeclAccessPair::make(TargetDecl, Access),
1517  BaseObjectType);
1518  Entity.setDiag(DD.getDiagnostic());
1519  CheckAccess(*this, Loc, Entity);
1520  } else {
1521  AccessTarget Entity(Context,
1522  AccessTarget::Base,
1523  cast<CXXRecordDecl>(TargetD),
1524  cast<CXXRecordDecl>(NamingD),
1525  Access);
1526  Entity.setDiag(DD.getDiagnostic());
1527  CheckAccess(*this, Loc, Entity);
1528  }
1529 }
1530 
1532  DeclAccessPair Found) {
1533  if (!getLangOpts().AccessControl ||
1534  !E->getNamingClass() ||
1535  Found.getAccess() == AS_public)
1536  return AR_accessible;
1537 
1538  AccessTarget Entity(Context, AccessTarget::Member, E->getNamingClass(),
1539  Found, QualType());
1540  Entity.setDiag(diag::err_access) << E->getSourceRange();
1541 
1542  return CheckAccess(*this, E->getNameLoc(), Entity);
1543 }
1544 
1545 /// Perform access-control checking on a previously-unresolved member
1546 /// access which has now been resolved to a member.
1548  DeclAccessPair Found) {
1549  if (!getLangOpts().AccessControl ||
1550  Found.getAccess() == AS_public)
1551  return AR_accessible;
1552 
1553  QualType BaseType = E->getBaseType();
1554  if (E->isArrow())
1555  BaseType = BaseType->getAs<PointerType>()->getPointeeType();
1556 
1557  AccessTarget Entity(Context, AccessTarget::Member, E->getNamingClass(),
1558  Found, BaseType);
1559  Entity.setDiag(diag::err_access) << E->getSourceRange();
1560 
1561  return CheckAccess(*this, E->getMemberLoc(), Entity);
1562 }
1563 
1564 /// Is the given special member function accessible for the purposes of
1565 /// deciding whether to define a special member function as deleted?
1567  AccessSpecifier access,
1568  QualType objectType) {
1569  // Fast path.
1570  if (access == AS_public || !getLangOpts().AccessControl) return true;
1571 
1572  AccessTarget entity(Context, AccessTarget::Member, decl->getParent(),
1573  DeclAccessPair::make(decl, access), objectType);
1574 
1575  // Suppress diagnostics.
1576  entity.setDiag(PDiag());
1577 
1578  switch (CheckAccess(*this, SourceLocation(), entity)) {
1579  case AR_accessible: return true;
1580  case AR_inaccessible: return false;
1581  case AR_dependent: llvm_unreachable("dependent for =delete computation");
1582  case AR_delayed: llvm_unreachable("cannot delay =delete computation");
1583  }
1584  llvm_unreachable("bad access result");
1585 }
1586 
1588  CXXDestructorDecl *Dtor,
1589  const PartialDiagnostic &PDiag,
1590  QualType ObjectTy) {
1591  if (!getLangOpts().AccessControl)
1592  return AR_accessible;
1593 
1594  // There's never a path involved when checking implicit destructor access.
1595  AccessSpecifier Access = Dtor->getAccess();
1596  if (Access == AS_public)
1597  return AR_accessible;
1598 
1599  CXXRecordDecl *NamingClass = Dtor->getParent();
1600  if (ObjectTy.isNull()) ObjectTy = Context.getTypeDeclType(NamingClass);
1601 
1602  AccessTarget Entity(Context, AccessTarget::Member, NamingClass,
1603  DeclAccessPair::make(Dtor, Access),
1604  ObjectTy);
1605  Entity.setDiag(PDiag); // TODO: avoid copy
1606 
1607  return CheckAccess(*this, Loc, Entity);
1608 }
1609 
1610 /// Checks access to a constructor.
1612  CXXConstructorDecl *Constructor,
1613  DeclAccessPair Found,
1614  const InitializedEntity &Entity,
1615  bool IsCopyBindingRefToTemp) {
1616  if (!getLangOpts().AccessControl || Found.getAccess() == AS_public)
1617  return AR_accessible;
1618 
1619  PartialDiagnostic PD(PDiag());
1620  switch (Entity.getKind()) {
1621  default:
1622  PD = PDiag(IsCopyBindingRefToTemp
1623  ? diag::ext_rvalue_to_reference_access_ctor
1624  : diag::err_access_ctor);
1625 
1626  break;
1627 
1629  PD = PDiag(diag::err_access_base_ctor);
1630  PD << Entity.isInheritedVirtualBase()
1631  << Entity.getBaseSpecifier()->getType() << getSpecialMember(Constructor);
1632  break;
1633 
1635  const FieldDecl *Field = cast<FieldDecl>(Entity.getDecl());
1636  PD = PDiag(diag::err_access_field_ctor);
1637  PD << Field->getType() << getSpecialMember(Constructor);
1638  break;
1639  }
1640 
1642  StringRef VarName = Entity.getCapturedVarName();
1643  PD = PDiag(diag::err_access_lambda_capture);
1644  PD << VarName << Entity.getType() << getSpecialMember(Constructor);
1645  break;
1646  }
1647 
1648  }
1649 
1650  return CheckConstructorAccess(UseLoc, Constructor, Found, Entity, PD);
1651 }
1652 
1653 /// Checks access to a constructor.
1655  CXXConstructorDecl *Constructor,
1656  DeclAccessPair Found,
1657  const InitializedEntity &Entity,
1658  const PartialDiagnostic &PD) {
1659  if (!getLangOpts().AccessControl ||
1660  Found.getAccess() == AS_public)
1661  return AR_accessible;
1662 
1663  CXXRecordDecl *NamingClass = Constructor->getParent();
1664 
1665  // Initializing a base sub-object is an instance method call on an
1666  // object of the derived class. Otherwise, we have an instance method
1667  // call on an object of the constructed type.
1668  //
1669  // FIXME: If we have a parent, we're initializing the base class subobject
1670  // in aggregate initialization. It's not clear whether the object class
1671  // should be the base class or the derived class in that case.
1672  CXXRecordDecl *ObjectClass;
1673  if ((Entity.getKind() == InitializedEntity::EK_Base ||
1675  !Entity.getParent()) {
1676  ObjectClass = cast<CXXConstructorDecl>(CurContext)->getParent();
1677  } else if (auto *Shadow =
1678  dyn_cast<ConstructorUsingShadowDecl>(Found.getDecl())) {
1679  // If we're using an inheriting constructor to construct an object,
1680  // the object class is the derived class, not the base class.
1681  ObjectClass = Shadow->getParent();
1682  } else {
1683  ObjectClass = NamingClass;
1684  }
1685 
1686  AccessTarget AccessEntity(
1687  Context, AccessTarget::Member, NamingClass,
1688  DeclAccessPair::make(Constructor, Found.getAccess()),
1689  Context.getTypeDeclType(ObjectClass));
1690  AccessEntity.setDiag(PD);
1691 
1692  return CheckAccess(*this, UseLoc, AccessEntity);
1693 }
1694 
1695 /// Checks access to an overloaded operator new or delete.
1697  SourceRange PlacementRange,
1698  CXXRecordDecl *NamingClass,
1699  DeclAccessPair Found,
1700  bool Diagnose) {
1701  if (!getLangOpts().AccessControl ||
1702  !NamingClass ||
1703  Found.getAccess() == AS_public)
1704  return AR_accessible;
1705 
1706  AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found,
1707  QualType());
1708  if (Diagnose)
1709  Entity.setDiag(diag::err_access)
1710  << PlacementRange;
1711 
1712  return CheckAccess(*this, OpLoc, Entity);
1713 }
1714 
1715 /// \brief Checks access to a member.
1717  CXXRecordDecl *NamingClass,
1718  DeclAccessPair Found) {
1719  if (!getLangOpts().AccessControl ||
1720  !NamingClass ||
1721  Found.getAccess() == AS_public)
1722  return AR_accessible;
1723 
1724  AccessTarget Entity(Context, AccessTarget::Member, NamingClass,
1725  Found, QualType());
1726 
1727  return CheckAccess(*this, UseLoc, Entity);
1728 }
1729 
1730 /// Checks access to an overloaded member operator, including
1731 /// conversion operators.
1733  Expr *ObjectExpr,
1734  Expr *ArgExpr,
1735  DeclAccessPair Found) {
1736  if (!getLangOpts().AccessControl ||
1737  Found.getAccess() == AS_public)
1738  return AR_accessible;
1739 
1740  const RecordType *RT = ObjectExpr->getType()->castAs<RecordType>();
1741  CXXRecordDecl *NamingClass = cast<CXXRecordDecl>(RT->getDecl());
1742 
1743  AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found,
1744  ObjectExpr->getType());
1745  Entity.setDiag(diag::err_access)
1746  << ObjectExpr->getSourceRange()
1747  << (ArgExpr ? ArgExpr->getSourceRange() : SourceRange());
1748 
1749  return CheckAccess(*this, OpLoc, Entity);
1750 }
1751 
1752 /// Checks access to the target of a friend declaration.
1754  assert(isa<CXXMethodDecl>(target->getAsFunction()));
1755 
1756  // Friendship lookup is a redeclaration lookup, so there's never an
1757  // inheritance path modifying access.
1758  AccessSpecifier access = target->getAccess();
1759 
1760  if (!getLangOpts().AccessControl || access == AS_public)
1761  return AR_accessible;
1762 
1763  CXXMethodDecl *method = cast<CXXMethodDecl>(target->getAsFunction());
1764 
1765  AccessTarget entity(Context, AccessTarget::Member,
1766  cast<CXXRecordDecl>(target->getDeclContext()),
1767  DeclAccessPair::make(target, access),
1768  /*no instance context*/ QualType());
1769  entity.setDiag(diag::err_access_friend_function)
1770  << (method->getQualifier() ? method->getQualifierLoc().getSourceRange()
1771  : method->getNameInfo().getSourceRange());
1772 
1773  // We need to bypass delayed-diagnostics because we might be called
1774  // while the ParsingDeclarator is active.
1775  EffectiveContext EC(CurContext);
1776  switch (CheckEffectiveAccess(*this, EC, target->getLocation(), entity)) {
1780  }
1781  llvm_unreachable("invalid access result");
1782 }
1783 
1785  DeclAccessPair Found) {
1786  if (!getLangOpts().AccessControl ||
1787  Found.getAccess() == AS_none ||
1788  Found.getAccess() == AS_public)
1789  return AR_accessible;
1790 
1791  OverloadExpr *Ovl = OverloadExpr::find(OvlExpr).Expression;
1792  CXXRecordDecl *NamingClass = Ovl->getNamingClass();
1793 
1794  AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found,
1795  /*no instance context*/ QualType());
1796  Entity.setDiag(diag::err_access)
1797  << Ovl->getSourceRange();
1798 
1799  return CheckAccess(*this, Ovl->getNameLoc(), Entity);
1800 }
1801 
1802 /// Checks access for a hierarchy conversion.
1803 ///
1804 /// \param ForceCheck true if this check should be performed even if access
1805 /// control is disabled; some things rely on this for semantics
1806 /// \param ForceUnprivileged true if this check should proceed as if the
1807 /// context had no special privileges
1809  QualType Base,
1810  QualType Derived,
1811  const CXXBasePath &Path,
1812  unsigned DiagID,
1813  bool ForceCheck,
1814  bool ForceUnprivileged) {
1815  if (!ForceCheck && !getLangOpts().AccessControl)
1816  return AR_accessible;
1817 
1818  if (Path.Access == AS_public)
1819  return AR_accessible;
1820 
1821  CXXRecordDecl *BaseD, *DerivedD;
1822  BaseD = cast<CXXRecordDecl>(Base->getAs<RecordType>()->getDecl());
1823  DerivedD = cast<CXXRecordDecl>(Derived->getAs<RecordType>()->getDecl());
1824 
1825  AccessTarget Entity(Context, AccessTarget::Base, BaseD, DerivedD,
1826  Path.Access);
1827  if (DiagID)
1828  Entity.setDiag(DiagID) << Derived << Base;
1829 
1830  if (ForceUnprivileged) {
1831  switch (CheckEffectiveAccess(*this, EffectiveContext(),
1832  AccessLoc, Entity)) {
1836  }
1837  llvm_unreachable("unexpected result from CheckEffectiveAccess");
1838  }
1839  return CheckAccess(*this, AccessLoc, Entity);
1840 }
1841 
1842 /// Checks access to all the declarations in the given result set.
1844  assert(getLangOpts().AccessControl
1845  && "performing access check without access control");
1846  assert(R.getNamingClass() && "performing access check without naming class");
1847 
1848  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
1849  if (I.getAccess() != AS_public) {
1850  AccessTarget Entity(Context, AccessedEntity::Member,
1851  R.getNamingClass(), I.getPair(),
1852  R.getBaseObjectType());
1853  Entity.setDiag(diag::err_access);
1854  CheckAccess(*this, R.getNameLoc(), Entity);
1855  }
1856  }
1857 }
1858 
1859 /// Checks access to Decl from the given class. The check will take access
1860 /// specifiers into account, but no member access expressions and such.
1861 ///
1862 /// \param Decl the declaration to check if it can be accessed
1863 /// \param Ctx the class/context from which to start the search
1864 /// \return true if the Decl is accessible from the Class, false otherwise.
1866  if (CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(Ctx)) {
1867  if (!Decl->isCXXClassMember())
1868  return true;
1869 
1870  QualType qType = Class->getTypeForDecl()->getCanonicalTypeInternal();
1871  AccessTarget Entity(Context, AccessedEntity::Member, Class,
1872  DeclAccessPair::make(Decl, Decl->getAccess()),
1873  qType);
1874  if (Entity.getAccess() == AS_public)
1875  return true;
1876 
1877  EffectiveContext EC(CurContext);
1878  return ::IsAccessible(*this, EC, Entity) != ::AR_inaccessible;
1879  }
1880 
1881  if (ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(Decl)) {
1882  // @public and @package ivars are always accessible.
1883  if (Ivar->getCanonicalAccessControl() == ObjCIvarDecl::Public ||
1884  Ivar->getCanonicalAccessControl() == ObjCIvarDecl::Package)
1885  return true;
1886 
1887  // If we are inside a class or category implementation, determine the
1888  // interface we're in.
1889  ObjCInterfaceDecl *ClassOfMethodDecl = nullptr;
1890  if (ObjCMethodDecl *MD = getCurMethodDecl())
1891  ClassOfMethodDecl = MD->getClassInterface();
1892  else if (FunctionDecl *FD = getCurFunctionDecl()) {
1893  if (ObjCImplDecl *Impl
1894  = dyn_cast<ObjCImplDecl>(FD->getLexicalDeclContext())) {
1895  if (ObjCImplementationDecl *IMPD
1896  = dyn_cast<ObjCImplementationDecl>(Impl))
1897  ClassOfMethodDecl = IMPD->getClassInterface();
1898  else if (ObjCCategoryImplDecl* CatImplClass
1899  = dyn_cast<ObjCCategoryImplDecl>(Impl))
1900  ClassOfMethodDecl = CatImplClass->getClassInterface();
1901  }
1902  }
1903 
1904  // If we're not in an interface, this ivar is inaccessible.
1905  if (!ClassOfMethodDecl)
1906  return false;
1907 
1908  // If we're inside the same interface that owns the ivar, we're fine.
1909  if (declaresSameEntity(ClassOfMethodDecl, Ivar->getContainingInterface()))
1910  return true;
1911 
1912  // If the ivar is private, it's inaccessible.
1913  if (Ivar->getCanonicalAccessControl() == ObjCIvarDecl::Private)
1914  return false;
1915 
1916  return Ivar->getContainingInterface()->isSuperClassOf(ClassOfMethodDecl);
1917  }
1918 
1919  return true;
1920 }
CXXRecordDecl * getNamingClass() const
Retrieve the naming class of this lookup.
Definition: ExprCXX.cpp:1282
Defines the clang::ASTContext interface.
static const Decl * getCanonicalDecl(const Decl *D)
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2285
QualType getPointeeType() const
Definition: Type.h:2298
A (possibly-)qualified type.
Definition: Type.h:653
base_class_range bases()
Definition: DeclCXX.h:773
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
AccessSpecifier getAccess() const
static void DelayDependentAccess(Sema &S, const EffectiveContext &EC, SourceLocation Loc, const AccessTarget &Entity)
static AccessResult MatchesFriend(Sema &S, const EffectiveContext &EC, const CXXRecordDecl *Friend)
Definition: SemaAccess.cpp:407
QualType getBaseObjectType() const
Returns the base object type associated with this lookup; important for [class.protected].
Definition: Lookup.h:418
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1270
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2736
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
Definition: DeclBase.h:948
NamedDecl * getDecl() const
SourceLocation getAccessLoc() const
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:95
A container of type source information.
Definition: Decl.h:86
The entity being initialized is a base member subobject.
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2397
std::list< CXXBasePath >::iterator paths_iterator
const PartialDiagnostic & getDiagnostic() const
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:54
void HandleDependentAccessCheck(const DependentDiagnostic &DD, const MultiLevelTemplateArgumentList &TemplateArgs)
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:806
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6307
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1576
AccessResult CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType objectType=QualType())
void CheckLookupAccess(const LookupResult &R)
Checks access to all the declarations in the given result set.
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
bool isInvalidDecl() const
Definition: DeclBase.h:546
EntityKind getKind() const
Determine the kind of initialization.
bool hasDefinition() const
Definition: DeclCXX.h:738
const CXXBaseSpecifier * getBaseSpecifier() const
Retrieve the base specifier.
Defines the clang::Expr interface and subclasses for C++ expressions.
Qualifiers getQualifiers() const
Retrieve all qualifiers.
AccessResult CheckFriendAccess(NamedDecl *D)
Checks access to the target of a friend declaration.
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:291
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Definition: DeclFriend.h:124
static AccessResult IsAccessible(Sema &S, const EffectiveContext &EC, AccessTarget &Entity)
Determines whether the accessed entity is accessible.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
bool isInheritedVirtualBase() const
Return whether the base is an inherited virtual base.
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2457
NamedDecl * getFriendDecl() const
If this friend declaration doesn&#39;t name a type, return the inner declaration.
Definition: DeclFriend.h:139
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3439
static bool TryDiagnoseProtectedAccess(Sema &S, const EffectiveContext &EC, AccessTarget &Target)
Given that an entity has protected natural access, check whether access might be denied because of th...
static AccessResult GetFriendKind(Sema &S, const EffectiveContext &EC, const CXXRecordDecl *Class)
Definition: SemaAccess.cpp:569
static AccessResult IsDerivedFromInclusive(const CXXRecordDecl *Derived, const CXXRecordDecl *Target)
Checks whether one class is derived from another, inclusively.
Definition: SemaAccess.cpp:279
StringRef getCapturedVarName() const
For a lambda capture, return the capture&#39;s name.
FunctionTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Represents the results of name lookup.
Definition: Lookup.h:32
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
AccessSpecifier getAccessSpecifier() const
Returns the access specifier for this base specifier.
Definition: DeclCXX.h:271
bool isSpecialMemberAccessibleForDeletion(CXXMethodDecl *decl, AccessSpecifier access, QualType objectType)
Is the given special member function accessible for the purposes of deciding whether to define a spec...
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:745
The entity being initialized is a non-static data member subobject.
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1152
AccessResult
A copy of Sema&#39;s enum without AR_delayed.
Definition: SemaAccess.cpp:30
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:705
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1149
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:820
AccessResult
Definition: Sema.h:5924
AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, DeclAccessPair FoundDecl, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp=false)
Checks access to a constructor.
const LangOptions & getLangOpts() const
Definition: Sema.h:1193
Represents an ObjC class declaration.
Definition: DeclObjC.h:1191
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:865
SourceLocation getMemberLoc() const
Definition: ExprCXX.h:3542
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Whether this is an anonymous struct or union.
Definition: Decl.h:3546
AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, DeclAccessPair FoundDecl)
Perform access-control checking on a previously-unresolved member access which has now been resolved ...
ValueDecl * getDecl() const
Retrieve the variable, parameter, or field being initialized.
Definition: SemaInit.cpp:2981
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:274
CXXRecordDecl * getNamingClass() const
Gets the naming class of this lookup, if any.
Definition: ExprCXX.cpp:380
Expr - This represents one expression.
Definition: Expr.h:106
bool isArrow() const
Determine whether this member expression used the &#39;->&#39; operator; otherwise, it used the &#39;...
Definition: ExprCXX.h:3524
A declaration being accessed, together with information about how it was accessed.
const FunctionProtoType * T
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2612
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6370
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2620
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
Definition: Decl.h:737
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:1048
bool isFileContext() const
Definition: DeclBase.h:1397
DeclContext * getDeclContext()
Definition: DeclBase.h:425
void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx)
QualType getType() const
Definition: Expr.h:128
PartialDiagnostic::StorageAllocator & getDiagAllocator()
Definition: ASTContext.h:667
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1331
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:42
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1026
static bool IsMicrosoftUsingDeclarationAccessBug(Sema &S, SourceLocation AccessLoc, AccessTarget &Entity)
MSVC has a bug where if during an using declaration name lookup, the declaration found is unaccessibl...
static bool MightInstantiateTo(const CXXRecordDecl *From, const CXXRecordDecl *To)
Checks whether one class might instantiate to the other.
Definition: SemaAccess.cpp:259
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1347
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1098
CanQualType getCanonicalTypeUnqualified() const
RecordDecl * getDecl() const
Definition: Type.h:3988
static AccessResult CheckEffectiveAccess(Sema &S, const EffectiveContext &EC, SourceLocation Loc, AccessTarget &Entity)
Checks access to an entity from the given effective context.
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2548
static CXXBasePath * FindBestPath(Sema &S, const EffectiveContext &EC, AccessTarget &Target, AccessSpecifier FinalAccess, CXXBasePaths &Paths)
Finds the best path from the naming class to the declaring class, taking friend declarations into acc...
Definition: SemaAccess.cpp:926
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:220
SourceLocation getNameLoc() const
Gets the location of the name.
Definition: ExprCXX.h:2658
Encodes a location in the source.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2934
bool IsSimplyAccessible(NamedDecl *decl, DeclContext *Ctx)
Checks access to Decl from the given class.
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
Definition: Sema.h:665
paths_iterator begin()
static void diagnoseBadDirectAccess(Sema &S, const EffectiveContext &EC, AccessTarget &entity)
We are unable to access a given declaration due to its direct access control; diagnose that...
NamedDecl * getAccessNamingClass() const
bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS)
SetMemberAccessSpecifier - Set the access specifier of a member.
Definition: SemaAccess.cpp:39
AccessSpecifier getAccess() const
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
Definition: DeclObjC.h:1829
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:1901
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4635
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
A POD class for pairing a NamedDecl* with an access specifier.
AccessResult CheckAllocationAccess(SourceLocation OperatorLoc, SourceRange PlacementRange, CXXRecordDecl *NamingClass, DeclAccessPair FoundDecl, bool Diagnose=true)
Checks access to an overloaded operator new or delete.
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2792
static CXXRecordDecl * FindDeclaringClass(NamedDecl *D)
Definition: SemaAccess.cpp:65
QualType getType() const
Retrieve type being initialized.
Dataflow Directional Tag Classes.
static Sema::AccessResult CheckAccess(Sema &S, SourceLocation Loc, AccessTarget &Entity)
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1252
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
static void DiagnoseBadAccess(Sema &S, SourceLocation Loc, const EffectiveContext &EC, AccessTarget &Entity)
AccessSpecifier getAccess() const
Definition: DeclBase.h:460
const InitializedEntity * getParent() const
Retrieve the parent of the entity being initialized, when the initialization itself is occurring with...
DeclarationName - The name of a declaration.
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:337
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2085
QualType getAccessBaseObjectType() const
friend_range friends() const
Definition: DeclFriend.h:248
CXXRecordDecl * getNamingClass() const
Gets the &#39;naming class&#39; (in the sense of C++0x [class.access.base]p5) of the lookup.
Definition: ExprCXX.h:2817
A dependently-generated diagnostic.
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2571
static DependentDiagnostic * Create(ASTContext &Context, DeclContext *Parent, AccessNonce _, SourceLocation Loc, bool IsMemberAccess, AccessSpecifier AS, NamedDecl *TargetDecl, CXXRecordDecl *NamingClass, QualType BaseObjectType, const PartialDiagnostic &PDiag)
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3978
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair FoundDecl)
Checks access to an overloaded member operator, including conversion operators.
Represents a base class of a C++ class.
Definition: DeclCXX.h:191
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2174
CXXRecordDecl * getNamingClass() const
Returns the &#39;naming class&#39; for this lookup, i.e.
Definition: Lookup.h:406
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1378
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
A diagnostic message which has been conditionally emitted pending the complete parsing of the current...
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1964
NamedDecl * getAccessTarget() const
The entity being initialized is the field that captures a variable in a lambda.
AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, DeclAccessPair FoundDecl)
AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, unsigned DiagID, bool ForceCheck=false, bool ForceUnprivileged=false)
Checks access for a hierarchy conversion.
AccessResult CheckMemberAccess(SourceLocation UseLoc, CXXRecordDecl *NamingClass, DeclAccessPair Found)
Checks access to a member.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:328
Declaration of a class template.
iterator end() const
Definition: Lookup.h:339
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:265
AccessSpecifier Access
The access along this inheritance path.
static void DiagnoseAccessPath(Sema &S, const EffectiveContext &EC, AccessTarget &entity)
Diagnose the path which caused the given declaration or base class to become inaccessible.
std::string getQualifiedNameAsString() const
Definition: Decl.cpp:1471
static AccessResult GetProtectedFriendKind(Sema &S, const EffectiveContext &EC, const CXXRecordDecl *InstanceContext, const CXXRecordDecl *NamingClass)
Search for a class P that EC is a friend of, under the constraint InstanceContext <= P if InstanceCon...
Definition: SemaAccess.cpp:710
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1860
The initialization is being done by a delegating constructor.
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1106
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
class clang::Sema::DelayedDiagnostics DelayedDiagnostics
QualType getType() const
Definition: Decl.h:638
AccessSpecifier getAccessSpecifierAsWritten() const
Retrieves the access specifier as written in the source code (which may mean that no access specifier...
Definition: DeclCXX.h:283
AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair FoundDecl)
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:316
paths_iterator end()
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2841
NamedDecl - This represents a decl with a name.
Definition: Decl.h:245
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:455
SourceRange getSourceRange() const LLVM_READONLY
Retrieves the source range that contains the entire base specifier.
Definition: DeclCXX.h:234
iterator begin() const
Definition: Lookup.h:338
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:609
Describes an entity that is being initialized.
SourceLocation getBegin() const
static AccessResult HasAccess(Sema &S, const EffectiveContext &EC, const CXXRecordDecl *NamingClass, AccessSpecifier Access, const AccessTarget &Target)
Definition: SemaAccess.cpp:728
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2518
bool isUnsupportedFriend() const
Determines if this friend kind is unsupported.
Definition: DeclFriend.h:175
QualType getBaseType() const
Definition: ExprCXX.h:3516
Declaration of a template function.
Definition: DeclTemplate.h:967
static DelayedDiagnostic makeAccess(SourceLocation Loc, const AccessedEntity &Entity)
SourceLocation getLocation() const
Definition: DeclBase.h:416
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3066
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:290