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