Bug Summary

File:tools/clang/lib/Sema/SemaAccess.cpp
Warning:line 1247, column 34
Access to field 'Base' results in a dereference of a null pointer (loaded from variable 'constrainingBase')

Annotated Source Code

1//===---- SemaAccess.cpp - C++ Access Control -------------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file provides Sema routines for C++ access control semantics.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Sema/SemaInternal.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/CXXInheritance.h"
17#include "clang/AST/DeclCXX.h"
18#include "clang/AST/DeclFriend.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DependentDiagnostic.h"
21#include "clang/AST/ExprCXX.h"
22#include "clang/Sema/DelayedDiagnostic.h"
23#include "clang/Sema/Initialization.h"
24#include "clang/Sema/Lookup.h"
25
26using namespace clang;
27using namespace sema;
28
29/// A copy of Sema's enum without AR_delayed.
30enum AccessResult {
31 AR_accessible,
32 AR_inaccessible,
33 AR_dependent
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).
39bool Sema::SetMemberAccessSpecifier(NamedDecl *MemberDecl,
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
65static CXXRecordDecl *FindDeclaringClass(NamedDecl *D) {
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
79namespace {
80struct 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;
142 SmallVector<FunctionDecl*, 4> Functions;
143 SmallVector<CXXRecordDecl*, 4> Records;
144 bool Dependent;
145};
146
147/// Like sema::AccessedEntity, but kindly lets us scribble all over
148/// it.
149struct 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)((HasInstanceContext) ? static_cast<void> (0) : __assert_fail
("HasInstanceContext", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 211, __PRETTY_FUNCTION__))
;
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
235private:
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.
259static 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.
279static AccessResult IsDerivedFromInclusive(const CXXRecordDecl *Derived,
280 const CXXRecordDecl *Target) {
281 assert(Derived->getCanonicalDecl() == Derived)((Derived->getCanonicalDecl() == Derived) ? static_cast<
void> (0) : __assert_fail ("Derived->getCanonicalDecl() == Derived"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 281, __PRETTY_FUNCTION__))
;
282 assert(Target->getCanonicalDecl() == Target)((Target->getCanonicalDecl() == Target) ? static_cast<void
> (0) : __assert_fail ("Target->getCanonicalDecl() == Target"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 282, __PRETTY_FUNCTION__))
;
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?")((T->isDependentType() && "non-dependent base wasn't a record?"
) ? static_cast<void> (0) : __assert_fail ("T->isDependentType() && \"non-dependent base wasn't a record?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 308, __PRETTY_FUNCTION__))
;
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
330static bool MightInstantiateTo(Sema &S, DeclContext *Context,
331 DeclContext *Friend) {
332 if (Friend == Context)
333 return true;
334
335 assert(!Friend->isDependentContext() &&((!Friend->isDependentContext() && "can't handle friends with dependent contexts here"
) ? static_cast<void> (0) : __assert_fail ("!Friend->isDependentContext() && \"can't handle friends with dependent contexts here\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 336, __PRETTY_FUNCTION__))
336 "can't handle friends with dependent contexts here")((!Friend->isDependentContext() && "can't handle friends with dependent contexts here"
) ? static_cast<void> (0) : __assert_fail ("!Friend->isDependentContext() && \"can't handle friends with dependent contexts here\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 336, __PRETTY_FUNCTION__))
;
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'.
350static 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
361static 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
372 CanQual<FunctionProtoType> FriendTy
373 = S.Context.getCanonicalType(Friend->getType())
374 ->getAs<FunctionProtoType>();
375 CanQual<FunctionProtoType> ContextTy
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
399static bool MightInstantiateTo(Sema &S,
400 FunctionTemplateDecl *Context,
401 FunctionTemplateDecl *Friend) {
402 return MightInstantiateTo(S,
403 Context->getTemplatedDecl(),
404 Friend->getTemplatedDecl());
405}
406
407static AccessResult MatchesFriend(Sema &S,
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
423static AccessResult MatchesFriend(Sema &S,
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.
438static AccessResult MatchesFriend(Sema &S,
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.
445 for (SmallVectorImpl<CXXRecordDecl*>::const_iterator
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.
491static AccessResult MatchesFriend(Sema &S,
492 const EffectiveContext &EC,
493 FunctionDecl *Friend) {
494 AccessResult OnFailure = AR_inaccessible;
495
496 for (SmallVectorImpl<FunctionDecl*>::const_iterator
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.
510static AccessResult MatchesFriend(Sema &S,
511 const EffectiveContext &EC,
512 FunctionTemplateDecl *Friend) {
513 if (EC.Functions.empty()) return AR_inaccessible;
514
515 AccessResult OnFailure = AR_inaccessible;
516
517 for (SmallVectorImpl<FunctionDecl*>::const_iterator
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.
540static AccessResult MatchesFriend(Sema &S,
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")((isa<FunctionDecl>(Friend) && "unknown friend decl kind"
) ? static_cast<void> (0) : __assert_fail ("isa<FunctionDecl>(Friend) && \"unknown friend decl kind\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 565, __PRETTY_FUNCTION__))
;
566 return MatchesFriend(S, EC, cast<FunctionDecl>(Friend));
567}
568
569static AccessResult GetFriendKind(Sema &S,
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
593namespace {
594
595/// A helper class for checking for a friend which will grant access
596/// to a protected instance member.
597struct 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.
605 SmallVector<const CXXRecordDecl*, 20> CurPath;
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())((I < CurPath.size()) ? static_cast<void> (0) : __assert_fail
("I < CurPath.size()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 618, __PRETTY_FUNCTION__))
;
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?")((T->isDependentType() && "non-dependent base wasn't a record?"
) ? static_cast<void> (0) : __assert_fail ("T->isDependentType() && \"non-dependent base wasn't a record?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 661, __PRETTY_FUNCTION__))
;
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())((CurPath.empty()) ? static_cast<void> (0) : __assert_fail
("CurPath.empty()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 677, __PRETTY_FUNCTION__))
;
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.
710static AccessResult GetProtectedFriendKind(Sema &S, const EffectiveContext &EC,
711 const CXXRecordDecl *InstanceContext,
712 const CXXRecordDecl *NamingClass) {
713 assert(InstanceContext == nullptr ||((InstanceContext == nullptr || InstanceContext->getCanonicalDecl
() == InstanceContext) ? static_cast<void> (0) : __assert_fail
("InstanceContext == nullptr || InstanceContext->getCanonicalDecl() == InstanceContext"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 714, __PRETTY_FUNCTION__))
714 InstanceContext->getCanonicalDecl() == InstanceContext)((InstanceContext == nullptr || InstanceContext->getCanonicalDecl
() == InstanceContext) ? static_cast<void> (0) : __assert_fail
("InstanceContext == nullptr || InstanceContext->getCanonicalDecl() == InstanceContext"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 714, __PRETTY_FUNCTION__))
;
715 assert(NamingClass->getCanonicalDecl() == NamingClass)((NamingClass->getCanonicalDecl() == NamingClass) ? static_cast
<void> (0) : __assert_fail ("NamingClass->getCanonicalDecl() == NamingClass"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 715, __PRETTY_FUNCTION__))
;
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
728static AccessResult HasAccess(Sema &S,
729 const EffectiveContext &EC,
730 const CXXRecordDecl *NamingClass,
731 AccessSpecifier Access,
732 const AccessTarget &Target) {
733 assert(NamingClass->getCanonicalDecl() == NamingClass &&((NamingClass->getCanonicalDecl() == NamingClass &&
"declaration should be canonicalized before being passed here"
) ? static_cast<void> (0) : __assert_fail ("NamingClass->getCanonicalDecl() == NamingClass && \"declaration should be canonicalized before being passed here\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 734, __PRETTY_FUNCTION__))
734 "declaration should be canonicalized before being passed here")((NamingClass->getCanonicalDecl() == NamingClass &&
"declaration should be canonicalized before being passed here"
) ? static_cast<void> (0) : __assert_fail ("NamingClass->getCanonicalDecl() == NamingClass && \"declaration should be canonicalized before being passed here\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 734, __PRETTY_FUNCTION__))
;
735
736 if (Access == AS_public) return AR_accessible;
737 assert(Access == AS_private || Access == AS_protected)((Access == AS_private || Access == AS_protected) ? static_cast
<void> (0) : __assert_fail ("Access == AS_private || Access == AS_protected"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 737, __PRETTY_FUNCTION__))
;
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)((Access == AS_protected) ? static_cast<void> (0) : __assert_fail
("Access == AS_protected", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 757, __PRETTY_FUNCTION__))
;
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())((Target.isInstanceMember()) ? static_cast<void> (0) : __assert_fail
("Target.isInstanceMember()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 818, __PRETTY_FUNCTION__))
;
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")::llvm::llvm_unreachable_internal("impossible friendship kind"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 857)
;
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")::llvm::llvm_unreachable_internal("impossible friendship kind"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 867)
;
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
926static CXXBasePath *FindBestPath(Sema &S,
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")((isDerived && "derived class not actually derived from base"
) ? static_cast<void> (0) : __assert_fail ("isDerived && \"derived class not actually derived from base\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 938, __PRETTY_FUNCTION__))
;
939 (void) isDerived;
940
941 CXXBasePath *BestPath = nullptr;
942
943 assert(FinalAccess != AS_none && "forbidden access after declaring class")((FinalAccess != AS_none && "forbidden access after declaring class"
) ? static_cast<void> (0) : __assert_fail ("FinalAccess != AS_none && \"forbidden access after declaring class\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 943, __PRETTY_FUNCTION__))
;
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)((PathAccess != AS_none) ? static_cast<void> (0) : __assert_fail
("PathAccess != AS_none", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 958, __PRETTY_FUNCTION__))
;
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) &&(((!BestPath || BestPath->Access != AS_public) && "fell out of loop with public path"
) ? static_cast<void> (0) : __assert_fail ("(!BestPath || BestPath->Access != AS_public) && \"fell out of loop with public path\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1003, __PRETTY_FUNCTION__))
1003 "fell out of loop with public path")(((!BestPath || BestPath->Access != AS_public) && "fell out of loop with public path"
) ? static_cast<void> (0) : __assert_fail ("(!BestPath || BestPath->Access != AS_public) && \"fell out of loop with public path\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1003, __PRETTY_FUNCTION__))
;
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
1018static 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())((Target.isMemberAccess()) ? static_cast<void> (0) : __assert_fail
("Target.isMemberAccess()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1024, __PRETTY_FUNCTION__))
;
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")((InstanceContext && "diagnosing dependent access") ?
static_cast<void> (0) : __assert_fail ("InstanceContext && \"diagnosing dependent access\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1061, __PRETTY_FUNCTION__))
;
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.
1093static void diagnoseBadDirectAccess(Sema &S,
1094 const EffectiveContext &EC,
1095 AccessTarget &entity) {
1096 assert(entity.isMemberAccess())((entity.isMemberAccess()) ? static_cast<void> (0) : __assert_fail
("entity.isMemberAccess()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1096, __PRETTY_FUNCTION__))
;
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.
1150static 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()) {
21
Assuming the condition is false
22
Taking false branch
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")::llvm::llvm_unreachable_internal("cannot diagnose dependent access"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1183)
;
1184 }
1185 }
1186
1187 CXXBasePaths paths;
1188 CXXBasePath &path = *FindBestPath(S, EC, entity, accessSoFar, paths);
1189 assert(path.Access != AS_public)((path.Access != AS_public) ? static_cast<void> (0) : __assert_fail
("path.Access != AS_public", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1189, __PRETTY_FUNCTION__))
;
1190
1191 CXXBasePath::iterator i = path.end(), e = path.begin();
1192 CXXBasePath::iterator constrainingBase = i;
1193 while (i != e) {
23
Assuming 'i' is not equal to 'e'
24
Loop condition is true. Entering loop body
31
Loop condition is false. Execution continues on line 1233
1194 --i;
1195
1196 assert(accessSoFar != AS_none && accessSoFar != AS_private)((accessSoFar != AS_none && accessSoFar != AS_private
) ? static_cast<void> (0) : __assert_fail ("accessSoFar != AS_none && accessSoFar != AS_private"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1196, __PRETTY_FUNCTION__))
;
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) {
25
Assuming 'baseAccess' is <= 'accessSoFar'
26
Taking false branch
1207 constrainingBase = i;
1208 accessSoFar = baseAccess;
1209 }
1210
1211 switch (HasAccess(S, EC, derivingClass, accessSoFar, entity)) {
27
Control jumps to 'case AR_accessible:' at line 1213
1212 case AR_inaccessible: break;
1213 case AR_accessible:
1214 accessSoFar = AS_public;
1215 entity.suppressInstanceContext();
1216 constrainingBase = nullptr;
28
Null pointer value stored to 'constrainingBase'
1217 break;
29
Execution continues on line 1224
1218 case AR_dependent:
1219 llvm_unreachable("cannot diagnose dependent access")::llvm::llvm_unreachable_internal("cannot diagnose dependent access"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1219)
;
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) {
30
Taking false branch
1225 assert(baseAccess == AS_private)((baseAccess == AS_private) ? static_cast<void> (0) : __assert_fail
("baseAccess == AS_private", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1225, __PRETTY_FUNCTION__))
;
1226 assert(constrainingBase == i)((constrainingBase == i) ? static_cast<void> (0) : __assert_fail
("constrainingBase == i", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1226, __PRETTY_FUNCTION__))
;
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())
32
Assuming the condition is false
33
Taking false branch
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() ||
34
Assuming the condition is true
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;
35
Access to field 'Base' results in a dereference of a null pointer (loaded from variable 'constrainingBase')
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
1259static void DiagnoseBadAccess(Sema &S, SourceLocation Loc,
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);
16
Assuming the condition is false
17
'?' condition is false
1265
1266 S.Diag(Loc, Entity.getDiag())
1267 << (Entity.getAccess() == AS_protected)
18
Assuming the condition is false
1268 << (D ? D->getDeclName() : DeclarationName())
19
'?' condition is false
1269 << S.Context.getTypeDeclType(NamingClass)
1270 << S.Context.getTypeDeclType(DeclaringClass);
1271 DiagnoseAccessPath(S, EC, Entity);
20
Calling 'DiagnoseAccessPath'
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.
1294static bool IsMicrosoftUsingDeclarationAccessBug(Sema& S,
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.
1314static AccessResult IsAccessible(Sema &S,
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")((UnprivilegedAccess != AS_public && "public access not weeded out"
) ? static_cast<void> (0) : __assert_fail ("UnprivilegedAccess != AS_public && \"public access not weeded out\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1321, __PRETTY_FUNCTION__))
;
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)((Entity.getDeclaringClass() != NamingClass) ? static_cast<
void> (0) : __assert_fail ("Entity.getDeclaringClass() != NamingClass"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1377, __PRETTY_FUNCTION__))
;
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 &&((Path->Access <= UnprivilegedAccess && "access along best path worse than direct?"
) ? static_cast<void> (0) : __assert_fail ("Path->Access <= UnprivilegedAccess && \"access along best path worse than direct?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1386, __PRETTY_FUNCTION__))
1386 "access along best path worse than direct?")((Path->Access <= UnprivilegedAccess && "access along best path worse than direct?"
) ? static_cast<void> (0) : __assert_fail ("Path->Access <= UnprivilegedAccess && \"access along best path worse than direct?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1386, __PRETTY_FUNCTION__))
;
1387 if (Path->Access == AS_public)
1388 return AR_accessible;
1389 return AR_inaccessible;
1390}
1391
1392static void DelayDependentAccess(Sema &S,
1393 const EffectiveContext &EC,
1394 SourceLocation Loc,
1395 const AccessTarget &Entity) {
1396 assert(EC.isDependent() && "delaying non-dependent access")((EC.isDependent() && "delaying non-dependent access"
) ? static_cast<void> (0) : __assert_fail ("EC.isDependent() && \"delaying non-dependent access\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1396, __PRETTY_FUNCTION__))
;
1397 DeclContext *DC = EC.getInnerContext();
1398 assert(DC->isDependentContext() && "delaying non-dependent access")((DC->isDependentContext() && "delaying non-dependent access"
) ? static_cast<void> (0) : __assert_fail ("DC->isDependentContext() && \"delaying non-dependent access\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1398, __PRETTY_FUNCTION__))
;
1399 DependentDiagnostic::Create(S.Context, DC, DependentDiagnostic::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.
1410static AccessResult CheckEffectiveAccess(Sema &S,
1411 const EffectiveContext &EC,
1412 SourceLocation Loc,
1413 AccessTarget &Entity) {
1414 assert(Entity.getAccess() != AS_public && "called for public access!")((Entity.getAccess() != AS_public && "called for public access!"
) ? static_cast<void> (0) : __assert_fail ("Entity.getAccess() != AS_public && \"called for public access!\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1414, __PRETTY_FUNCTION__))
;
1415
1416 switch (IsAccessible(S, EC, Entity)) {
12
Control jumps to 'case AR_inaccessible:' at line 1421
1417 case AR_dependent:
1418 DelayDependentAccess(S, EC, Loc, Entity);
1419 return AR_dependent;
1420
1421 case AR_inaccessible:
1422 if (S.getLangOpts().MSVCCompat &&
13
Assuming the condition is false
1423 IsMicrosoftUsingDeclarationAccessBug(S, Loc, Entity))
1424 return AR_accessible;
1425 if (!Entity.isQuiet())
14
Taking true branch
1426 DiagnoseBadAccess(S, Loc, EC, Entity);
15
Calling 'DiagnoseBadAccess'
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")::llvm::llvm_unreachable_internal("invalid access result", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1434)
;
1435}
1436
1437static Sema::AccessResult CheckAccess(Sema &S, SourceLocation Loc,
1438 AccessTarget &Entity) {
1439 // If the access path is public, it's accessible everywhere.
1440 if (Entity.getAccess() == AS_public)
9
Taking false branch
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);
1454 if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {
10
Taking false branch
1455 S.DelayedDiagnostics.add(DelayedDiagnostic::makeAccess(Loc, Entity));
1456 return Sema::AR_delayed;
1457 }
1458
1459 EffectiveContext EC(S.CurContext);
1460 switch (CheckEffectiveAccess(S, EC, Loc, Entity)) {
11
Calling 'CheckEffectiveAccess'
1461 case AR_accessible: return Sema::AR_accessible;
1462 case AR_inaccessible: return Sema::AR_inaccessible;
1463 case AR_dependent: return Sema::AR_dependent;
1464 }
1465 llvm_unreachable("invalid access result")::llvm::llvm_unreachable_internal("invalid access result", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1465)
;
1466}
1467
1468void Sema::HandleDelayedAccessCheck(DelayedDiagnostic &DD, Decl *D) {
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
1491void Sema::HandleDependentAccessCheck(const DependentDiagnostic &DD,
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
1531Sema::AccessResult Sema::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,
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.
1547Sema::AccessResult Sema::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,
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?
1566bool Sema::isSpecialMemberAccessibleForDeletion(CXXMethodDecl *decl,
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")::llvm::llvm_unreachable_internal("dependent for =delete computation"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1581)
;
1582 case AR_delayed: llvm_unreachable("cannot delay =delete computation")::llvm::llvm_unreachable_internal("cannot delay =delete computation"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1582)
;
1583 }
1584 llvm_unreachable("bad access result")::llvm::llvm_unreachable_internal("bad access result", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1584)
;
1585}
1586
1587Sema::AccessResult Sema::CheckDestructorAccess(SourceLocation Loc,
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.
1611Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc,
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
1628 case InitializedEntity::EK_Base:
1629 PD = PDiag(diag::err_access_base_ctor);
1630 PD << Entity.isInheritedVirtualBase()
1631 << Entity.getBaseSpecifier()->getType() << getSpecialMember(Constructor);
1632 break;
1633
1634 case InitializedEntity::EK_Member: {
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
1641 case InitializedEntity::EK_LambdaCapture: {
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.
1654Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc,
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 ||
1674 Entity.getKind() == InitializedEntity::EK_Delegating) &&
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.
1696Sema::AccessResult Sema::CheckAllocationAccess(SourceLocation OpLoc,
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.
1716Sema::AccessResult Sema::CheckMemberAccess(SourceLocation UseLoc,
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.
1732Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc,
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.
1753Sema::AccessResult Sema::CheckFriendAccess(NamedDecl *target) {
1754 assert(isa<CXXMethodDecl>(target->getAsFunction()))((isa<CXXMethodDecl>(target->getAsFunction())) ? static_cast
<void> (0) : __assert_fail ("isa<CXXMethodDecl>(target->getAsFunction())"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1754, __PRETTY_FUNCTION__))
;
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)) {
1777 case ::AR_accessible: return Sema::AR_accessible;
1778 case ::AR_inaccessible: return Sema::AR_inaccessible;
1779 case ::AR_dependent: return Sema::AR_dependent;
1780 }
1781 llvm_unreachable("invalid access result")::llvm::llvm_unreachable_internal("invalid access result", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1781)
;
1782}
1783
1784Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr,
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
1808Sema::AccessResult Sema::CheckBaseClassAccess(SourceLocation AccessLoc,
1809 QualType Base,
1810 QualType Derived,
1811 const CXXBasePath &Path,
1812 unsigned DiagID,
1813 bool ForceCheck,
1814 bool ForceUnprivileged) {
1815 if (!ForceCheck && !getLangOpts().AccessControl)
1
Assuming 'ForceCheck' is not equal to 0
1816 return AR_accessible;
1817
1818 if (Path.Access == AS_public)
2
Assuming the condition is false
3
Taking false branch
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)
4
Assuming 'DiagID' is 0
5
Taking false branch
1828 Entity.setDiag(DiagID) << Derived << Base;
1829
1830 if (ForceUnprivileged) {
6
Assuming 'ForceUnprivileged' is 0
7
Taking false branch
1831 switch (CheckEffectiveAccess(*this, EffectiveContext(),
1832 AccessLoc, Entity)) {
1833 case ::AR_accessible: return Sema::AR_accessible;
1834 case ::AR_inaccessible: return Sema::AR_inaccessible;
1835 case ::AR_dependent: return Sema::AR_dependent;
1836 }
1837 llvm_unreachable("unexpected result from CheckEffectiveAccess")::llvm::llvm_unreachable_internal("unexpected result from CheckEffectiveAccess"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1837)
;
1838 }
1839 return CheckAccess(*this, AccessLoc, Entity);
8
Calling 'CheckAccess'
1840}
1841
1842/// Checks access to all the declarations in the given result set.
1843void Sema::CheckLookupAccess(const LookupResult &R) {
1844 assert(getLangOpts().AccessControl((getLangOpts().AccessControl && "performing access check without access control"
) ? static_cast<void> (0) : __assert_fail ("getLangOpts().AccessControl && \"performing access check without access control\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1845, __PRETTY_FUNCTION__))
1845 && "performing access check without access control")((getLangOpts().AccessControl && "performing access check without access control"
) ? static_cast<void> (0) : __assert_fail ("getLangOpts().AccessControl && \"performing access check without access control\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1845, __PRETTY_FUNCTION__))
;
1846 assert(R.getNamingClass() && "performing access check without naming class")((R.getNamingClass() && "performing access check without naming class"
) ? static_cast<void> (0) : __assert_fail ("R.getNamingClass() && \"performing access check without naming class\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/Sema/SemaAccess.cpp"
, 1846, __PRETTY_FUNCTION__))
;
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.
1865bool Sema::IsSimplyAccessible(NamedDecl *Decl, DeclContext *Ctx) {
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}