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