| //===---- SemaAccess.cpp - C++ Access Control -------------------*- C++ -*-===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file provides Sema routines for C++ access control semantics. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "clang/AST/ASTContext.h" | |
| #include "clang/AST/CXXInheritance.h" | |
| #include "clang/AST/DeclCXX.h" | |
| #include "clang/AST/DeclFriend.h" | |
| #include "clang/AST/DeclObjC.h" | |
| #include "clang/AST/DependentDiagnostic.h" | |
| #include "clang/AST/ExprCXX.h" | |
| #include "clang/Basic/Specifiers.h" | |
| #include "clang/Sema/DelayedDiagnostic.h" | |
| #include "clang/Sema/Initialization.h" | |
| #include "clang/Sema/Lookup.h" | |
| #include "clang/Sema/Template.h" | |
| #include "clang/Sema/TemplateDeduction.h" | |
| #include "llvm/ADT/ScopeExit.h" | |
| using namespace clang; | |
| using namespace sema; | |
| /// A copy of Sema's enum without AR_delayed. | |
| enum AccessResult { | |
| AR_accessible, | |
| AR_inaccessible, | |
| AR_dependent | |
| }; | |
| bool Sema::SetMemberAccessSpecifier(NamedDecl *MemberDecl, | |
| NamedDecl *PrevMemberDecl, | |
| AccessSpecifier LexicalAS) { | |
| if (!PrevMemberDecl) { | |
| // Use the lexical access specifier. | |
| MemberDecl->setAccess(LexicalAS); | |
| return false; | |
| } | |
| // C++ [class.access.spec]p3: When a member is redeclared its access | |
| // specifier must be same as its initial declaration. | |
| if (LexicalAS != AS_none && LexicalAS != PrevMemberDecl->getAccess()) { | |
| Diag(MemberDecl->getLocation(), | |
| diag::err_class_redeclared_with_different_access) | |
| << MemberDecl << LexicalAS; | |
| Diag(PrevMemberDecl->getLocation(), diag::note_previous_access_declaration) | |
| << PrevMemberDecl << PrevMemberDecl->getAccess(); | |
| MemberDecl->setAccess(LexicalAS); | |
| return true; | |
| } | |
| MemberDecl->setAccess(PrevMemberDecl->getAccess()); | |
| return false; | |
| } | |
| static CXXRecordDecl *FindDeclaringClass(NamedDecl *D) { | |
| DeclContext *DC = D->getDeclContext(); | |
| // This can only happen at top: enum decls only "publish" their | |
| // immediate members. | |
| if (isa<EnumDecl>(DC)) | |
| DC = cast<EnumDecl>(DC)->getDeclContext(); | |
| CXXRecordDecl *DeclaringClass = cast<CXXRecordDecl>(DC); | |
| while (DeclaringClass->isAnonymousStructOrUnion()) | |
| DeclaringClass = cast<CXXRecordDecl>(DeclaringClass->getDeclContext()); | |
| return DeclaringClass; | |
| } | |
| namespace { | |
| struct EffectiveContext { | |
| EffectiveContext() : Inner(nullptr), Dependent(false) {} | |
| explicit EffectiveContext(DeclContext *DC) | |
| : Inner(DC), | |
| Dependent(DC->isDependentContext()) { | |
| // An implicit deduction guide is semantically in the context enclosing the | |
| // class template, but for access purposes behaves like the constructor | |
| // from which it was produced. | |
| if (auto *DGD = dyn_cast<CXXDeductionGuideDecl>(DC)) { | |
| if (DGD->isImplicit()) { | |
| DC = DGD->getCorrespondingConstructor(); | |
| if (!DC) { | |
| // The copy deduction candidate doesn't have a corresponding | |
| // constructor. | |
| DC = cast<DeclContext>(DGD->getDeducedTemplate()->getTemplatedDecl()); | |
| } | |
| } | |
| } | |
| // C++11 [class.access.nest]p1: | |
| // A nested class is a member and as such has the same access | |
| // rights as any other member. | |
| // C++11 [class.access]p2: | |
| // A member of a class can also access all the names to which | |
| // the class has access. A local class of a member function | |
| // may access the same names that the member function itself | |
| // may access. | |
| // This almost implies that the privileges of nesting are transitive. | |
| // Technically it says nothing about the local classes of non-member | |
| // functions (which can gain privileges through friendship), but we | |
| // take that as an oversight. | |
| while (true) { | |
| // We want to add canonical declarations to the EC lists for | |
| // simplicity of checking, but we need to walk up through the | |
| // actual current DC chain. Otherwise, something like a local | |
| // extern or friend which happens to be the canonical | |
| // declaration will really mess us up. | |
| if (isa<CXXRecordDecl>(DC)) { | |
| CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); | |
| Records.push_back(Record->getCanonicalDecl()); | |
| DC = Record->getDeclContext(); | |
| } else if (isa<FunctionDecl>(DC)) { | |
| FunctionDecl *Function = cast<FunctionDecl>(DC); | |
| Functions.push_back(Function->getCanonicalDecl()); | |
| if (Function->getFriendObjectKind()) | |
| DC = Function->getLexicalDeclContext(); | |
| else | |
| DC = Function->getDeclContext(); | |
| } else if (DC->isFileContext()) { | |
| break; | |
| } else { | |
| DC = DC->getParent(); | |
| } | |
| } | |
| } | |
| bool isDependent() const { return Dependent; } | |
| bool includesClass(const CXXRecordDecl *R) const { | |
| R = R->getCanonicalDecl(); | |
| return llvm::is_contained(Records, R); | |
| } | |
| /// Retrieves the innermost "useful" context. Can be null if we're | |
| /// doing access-control without privileges. | |
| DeclContext *getInnerContext() const { | |
| return Inner; | |
| } | |
| typedef SmallVectorImpl<CXXRecordDecl*>::const_iterator record_iterator; | |
| DeclContext *Inner; | |
| SmallVector<FunctionDecl*, 4> Functions; | |
| SmallVector<CXXRecordDecl*, 4> Records; | |
| bool Dependent; | |
| }; | |
| /// Like sema::AccessedEntity, but kindly lets us scribble all over | |
| /// it. | |
| struct AccessTarget : public AccessedEntity { | |
| AccessTarget(const AccessedEntity &Entity) | |
| : AccessedEntity(Entity) { | |
| initialize(); | |
| } | |
| AccessTarget(ASTContext &Context, | |
| MemberNonce _, | |
| CXXRecordDecl *NamingClass, | |
| DeclAccessPair FoundDecl, | |
| QualType BaseObjectType) | |
| : AccessedEntity(Context.getDiagAllocator(), Member, NamingClass, | |
| FoundDecl, BaseObjectType) { | |
| initialize(); | |
| } | |
| AccessTarget(ASTContext &Context, | |
| BaseNonce _, | |
| CXXRecordDecl *BaseClass, | |
| CXXRecordDecl *DerivedClass, | |
| AccessSpecifier Access) | |
| : AccessedEntity(Context.getDiagAllocator(), Base, BaseClass, DerivedClass, | |
| Access) { | |
| initialize(); | |
| } | |
| bool isInstanceMember() const { | |
| return (isMemberAccess() && getTargetDecl()->isCXXInstanceMember()); | |
| } | |
| bool hasInstanceContext() const { | |
| return HasInstanceContext; | |
| } | |
| class SavedInstanceContext { | |
| public: | |
| SavedInstanceContext(SavedInstanceContext &&S) | |
| : Target(S.Target), Has(S.Has) { | |
| S.Target = nullptr; | |
| } | |
| // The move assignment operator is defined as deleted pending further | |
| // motivation. | |
| SavedInstanceContext &operator=(SavedInstanceContext &&) = delete; | |
| // The copy constrcutor and copy assignment operator is defined as deleted | |
| // pending further motivation. | |
| SavedInstanceContext(const SavedInstanceContext &) = delete; | |
| SavedInstanceContext &operator=(const SavedInstanceContext &) = delete; | |
| ~SavedInstanceContext() { | |
| if (Target) | |
| Target->HasInstanceContext = Has; | |
| } | |
| private: | |
| friend struct AccessTarget; | |
| explicit SavedInstanceContext(AccessTarget &Target) | |
| : Target(&Target), Has(Target.HasInstanceContext) {} | |
| AccessTarget *Target; | |
| bool Has; | |
| }; | |
| SavedInstanceContext saveInstanceContext() { | |
| return SavedInstanceContext(*this); | |
| } | |
| void suppressInstanceContext() { | |
| HasInstanceContext = false; | |
| } | |
| const CXXRecordDecl *resolveInstanceContext(Sema &S) const { | |
| assert(HasInstanceContext); | |
| if (CalculatedInstanceContext) | |
| return InstanceContext; | |
| CalculatedInstanceContext = true; | |
| DeclContext *IC = S.computeDeclContext(getBaseObjectType()); | |
| InstanceContext = (IC ? cast<CXXRecordDecl>(IC)->getCanonicalDecl() | |
| : nullptr); | |
| return InstanceContext; | |
| } | |
| const CXXRecordDecl *getDeclaringClass() const { | |
| return DeclaringClass; | |
| } | |
| /// The "effective" naming class is the canonical non-anonymous | |
| /// class containing the actual naming class. | |
| const CXXRecordDecl *getEffectiveNamingClass() const { | |
| const CXXRecordDecl *namingClass = getNamingClass(); | |
| while (namingClass->isAnonymousStructOrUnion()) | |
| namingClass = cast<CXXRecordDecl>(namingClass->getParent()); | |
| return namingClass->getCanonicalDecl(); | |
| } | |
| private: | |
| void initialize() { | |
| HasInstanceContext = (isMemberAccess() && | |
| !getBaseObjectType().isNull() && | |
| getTargetDecl()->isCXXInstanceMember()); | |
| CalculatedInstanceContext = false; | |
| InstanceContext = nullptr; | |
| if (isMemberAccess()) | |
| DeclaringClass = FindDeclaringClass(getTargetDecl()); | |
| else | |
| DeclaringClass = getBaseClass(); | |
| DeclaringClass = DeclaringClass->getCanonicalDecl(); | |
| } | |
| bool HasInstanceContext : 1; | |
| mutable bool CalculatedInstanceContext : 1; | |
| mutable const CXXRecordDecl *InstanceContext; | |
| const CXXRecordDecl *DeclaringClass; | |
| }; | |
| } // namespace | |
| static CanQual<FunctionProtoType> GetCanonicalFunctionProto(ASTContext &Context, | |
| QualType Ty) { | |
| return Context.getCanonicalType(Ty)->getAs<FunctionProtoType>(); | |
| } | |
| static CanQual<FunctionProtoType> | |
| GetCanonicalFunctionProto(ASTContext &Context, const FunctionDecl *FD) { | |
| return GetCanonicalFunctionProto(Context, FD->getType()); | |
| } | |
| static const TemplateSpecializationType * | |
| GetQualifierClassTemplateSpecializationType(ASTContext &Context, | |
| NestedNameSpecifier NNS) { | |
| if (!NNS || NNS.getKind() != NestedNameSpecifier::Kind::Type) | |
| return nullptr; | |
| QualType Ty(NNS.getAsType(), 0); | |
| if (const auto *ICNT = Ty->getAs<InjectedClassNameType>()) | |
| Ty = ICNT->getDecl()->getCanonicalTemplateSpecializationType(Context); | |
| const auto *TST = Ty->getAsNonAliasTemplateSpecializationType(); | |
| if (TST && isa_and_nonnull<ClassTemplateDecl>( | |
| TST->getTemplateName().getAsTemplateDecl())) | |
| return TST; | |
| return nullptr; | |
| } | |
| static FunctionTemplateDecl *TryGetFunctionTemplateDecl(FunctionDecl *FD) { | |
| if (auto *FTD = FD->getPrimaryTemplate()) | |
| return FTD->getCanonicalDecl(); | |
| if (auto *FTD = FD->getDescribedFunctionTemplate()) | |
| return FTD->getCanonicalDecl(); | |
| if (FunctionDecl *Pattern = | |
| FD->getTemplateInstantiationPattern(/*ForDefinition=*/false)) { | |
| if (auto *FTD = Pattern->getDescribedFunctionTemplate()) | |
| return FTD->getCanonicalDecl(); | |
| if (auto *FTD = Pattern->getPrimaryTemplate()) | |
| return FTD->getCanonicalDecl(); | |
| } | |
| return nullptr; | |
| } | |
| static ClassTemplateDecl *GetClassTemplatePattern(ClassTemplateDecl *CTD) { | |
| while (ClassTemplateDecl *Pattern = CTD->getInstantiatedFromMemberTemplate()) | |
| CTD = Pattern; | |
| return CTD; | |
| } | |
| static ClassTemplateDecl *GetClassTemplateDecl(CXXRecordDecl *RD) { | |
| if (auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) | |
| return Spec->getSpecializedTemplate(); | |
| return RD->getDescribedClassTemplate(); | |
| } | |
| static TemplateParameterList * | |
| SubstTemplateParameterList(Sema &S, TemplateParameterList *TPL, DeclContext *DC, | |
| const MultiLevelTemplateArgumentList &Args) { | |
| TemplateParameterList *InstTPL = | |
| S.SubstTemplateParams(TPL, DC, Args, | |
| /*EvaluateConstraints=*/false); | |
| if (!InstTPL || !TPL->getRequiresClause()) | |
| return InstTPL; | |
| ExprResult InstRequiresClause = | |
| S.SubstConstraintExprWithoutSatisfaction(TPL->getRequiresClause(), Args); | |
| if (!InstRequiresClause.isUsable()) | |
| return nullptr; | |
| return TemplateParameterList::Create( | |
| S.Context, InstTPL->getTemplateLoc(), InstTPL->getLAngleLoc(), | |
| InstTPL->asArray(), InstTPL->getRAngleLoc(), InstRequiresClause.get()); | |
| } | |
| static AccessResult | |
| DeduceTemplateArguments(Sema &S, FriendTemplateDecl *FTD, DeclContext *DC, | |
| const TemplateSpecializationType *TST, | |
| ArrayRef<TemplateParameterList *> TPLs, | |
| TemplateSpecCandidateSet *FailedTSC, | |
| MultiLevelTemplateArgumentList &DeducedArgs) { | |
| const auto *CandidateRD = dyn_cast<CXXRecordDecl>(DC); | |
| if (!CandidateRD) | |
| return AR_inaccessible; | |
| ClassTemplateDecl *CandidateCTD = CandidateRD->getDescribedClassTemplate(); | |
| ArrayRef<TemplateArgument> CandidateArgs; | |
| if (CandidateCTD) { | |
| CandidateArgs = CandidateCTD->getInjectedTemplateArgs(S.Context); | |
| } else { | |
| const auto *CandidateSpec = | |
| dyn_cast<ClassTemplateSpecializationDecl>(CandidateRD); | |
| if (!CandidateSpec) | |
| return AR_inaccessible; | |
| CandidateCTD = CandidateSpec->getSpecializedTemplate(); | |
| CandidateArgs = CandidateSpec->getTemplateArgs().asArray(); | |
| } | |
| auto *PatternCTD = dyn_cast_if_present<ClassTemplateDecl>( | |
| TST->getTemplateName().getAsTemplateDecl()); | |
| if (!PatternCTD || !declaresSameEntity(GetClassTemplatePattern(CandidateCTD), | |
| GetClassTemplatePattern(PatternCTD))) | |
| return AR_inaccessible; | |
| if (S.DeduceTemplateArguments(FTD, PatternCTD, CandidateCTD, TPLs, | |
| TST->template_arguments(), CandidateArgs, | |
| FTD->getLocation(), FailedTSC, DeducedArgs)) | |
| return AR_accessible; | |
| return CandidateRD->isDependentContext() ? AR_dependent : AR_inaccessible; | |
| } | |
| class FriendTemplateMatchContext { | |
| Sema &S; | |
| FriendTemplateDecl *FTD; | |
| Sema::InstantiatingTemplate Inst; | |
| TemplateDeductionInfo Info; | |
| MultiLevelTemplateArgumentList DeducedArgs; | |
| Sema::SFINAETrap Trap; | |
| LocalInstantiationScope InstantiationScope; | |
| AccessResult Result = AR_inaccessible; | |
| public: | |
| FriendTemplateMatchContext(Sema &S, FriendTemplateDecl *FTD) | |
| : S(S), FTD(FTD), Inst(S, FTD->getLocation(), FTD), | |
| Info(FTD->getLocation()), Trap(S, Info), InstantiationScope(S) {} | |
| AccessResult deduce(DeclContext *DC, const TemplateSpecializationType *TST, | |
| ArrayRef<TemplateParameterList *> TPLs, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| if (Inst.isInvalid()) | |
| return Result = AR_inaccessible; | |
| return Result = DeduceTemplateArguments(S, FTD, DC, TST, TPLs, FailedTSC, | |
| DeducedArgs); | |
| } | |
| AccessResult getAccessResult() const { return Result; } | |
| MultiLevelTemplateArgumentList &getDeducedArgs() { return DeducedArgs; } | |
| bool hasDeducedArgs() const { return Result == AR_accessible; } | |
| bool hasErrorOccurred() const { return Trap.hasErrorOccurred(); } | |
| }; | |
| static bool HasSameFunctionType(Sema &S, QualType FriendType, | |
| QualType ContextType, SourceLocation Loc) { | |
| if (!S.Context.hasSameFunctionTypeIgnoringExceptionSpec(FriendType, | |
| ContextType)) | |
| return false; | |
| const auto *FriendFPT = FriendType->castAs<FunctionProtoType>(); | |
| const auto *ContextFPT = ContextType->castAs<FunctionProtoType>(); | |
| return !S.CheckEquivalentExceptionSpec(S.PDiag(), S.PDiag(), FriendFPT, Loc, | |
| ContextFPT, Loc); | |
| } | |
| /// Checks whether one class might instantiate to the other. | |
| static bool MightInstantiateTo(const CXXRecordDecl *From, | |
| const CXXRecordDecl *To) { | |
| // Declaration names are always preserved by instantiation. | |
| if (From->getDeclName() != To->getDeclName()) | |
| return false; | |
| const DeclContext *FromDC = From->getDeclContext()->getPrimaryContext(); | |
| const DeclContext *ToDC = To->getDeclContext()->getPrimaryContext(); | |
| if (FromDC == ToDC) | |
| return true; | |
| if (FromDC->isFileContext() || ToDC->isFileContext()) | |
| return false; | |
| // Be conservative. | |
| return true; | |
| } | |
| /// Checks whether one class is derived from another, inclusively. | |
| /// Properly indicates when it couldn't be determined due to | |
| /// dependence. | |
| /// | |
| /// This should probably be donated to AST or at least Sema. | |
| static AccessResult IsDerivedFromInclusive(const CXXRecordDecl *Derived, | |
| const CXXRecordDecl *Target) { | |
| assert(Derived->getCanonicalDecl() == Derived); | |
| assert(Target->getCanonicalDecl() == Target); | |
| if (Derived == Target) return AR_accessible; | |
| bool CheckDependent = Derived->isDependentContext(); | |
| if (CheckDependent && MightInstantiateTo(Derived, Target)) | |
| return AR_dependent; | |
| AccessResult OnFailure = AR_inaccessible; | |
| SmallVector<const CXXRecordDecl*, 8> Queue; // actually a stack | |
| while (true) { | |
| if (Derived->isDependentContext() && !Derived->hasDefinition() && | |
| !Derived->isLambda()) | |
| return AR_dependent; | |
| for (const auto &I : Derived->bases()) { | |
| const CXXRecordDecl *RD; | |
| QualType T = I.getType(); | |
| if (CXXRecordDecl *Rec = T->getAsCXXRecordDecl()) { | |
| RD = Rec; | |
| } else { | |
| assert(T->isDependentType() && "non-dependent base wasn't a record?"); | |
| OnFailure = AR_dependent; | |
| continue; | |
| } | |
| RD = RD->getCanonicalDecl(); | |
| if (RD == Target) return AR_accessible; | |
| if (CheckDependent && MightInstantiateTo(RD, Target)) | |
| OnFailure = AR_dependent; | |
| Queue.push_back(RD); | |
| } | |
| if (Queue.empty()) break; | |
| Derived = Queue.pop_back_val(); | |
| } | |
| return OnFailure; | |
| } | |
| static bool MightInstantiateTo(DeclContext *Context, DeclContext *Friend) { | |
| if (Friend == Context) | |
| return true; | |
| assert(!Friend->isDependentContext() && | |
| "can't handle friends with dependent contexts here"); | |
| if (!Context->isDependentContext()) | |
| return false; | |
| if (Friend->isFileContext()) | |
| return false; | |
| // TODO: this is very conservative | |
| return true; | |
| } | |
| // Asks whether the type in 'context' can ever instantiate to the type | |
| // in 'friend'. | |
| static bool MightInstantiateTo(CanQualType Context, CanQualType Friend) { | |
| if (Friend == Context) | |
| return true; | |
| if (!Friend->isDependentType() && !Context->isDependentType()) | |
| return false; | |
| // TODO: this is very conservative. | |
| return true; | |
| } | |
| static bool MightInstantiateTo(CanQual<FunctionProtoType> Context, | |
| CanQual<FunctionProtoType> Friend) { | |
| if (Friend.getQualifiers() != Context.getQualifiers()) | |
| return false; | |
| if (Friend->getNumParams() != Context->getNumParams()) | |
| return false; | |
| if (!MightInstantiateTo(Context->getReturnType(), Friend->getReturnType())) | |
| return false; | |
| for (unsigned I = 0, E = Friend->getNumParams(); I != E; ++I) | |
| if (!MightInstantiateTo(Context->getParamType(I), Friend->getParamType(I))) | |
| return false; | |
| return true; | |
| } | |
| static bool MightInstantiateTo(ASTContext &Ctx, DeclarationName Context, | |
| DeclarationName Friend) { | |
| if (Context == Friend) | |
| return true; | |
| if (Context.getNameKind() != Friend.getNameKind()) | |
| return false; | |
| switch (Context.getNameKind()) { | |
| case DeclarationName::CXXConstructorName: | |
| case DeclarationName::CXXDestructorName: | |
| case DeclarationName::CXXConversionFunctionName: | |
| return MightInstantiateTo(Ctx.getCanonicalType(Context.getCXXNameType()), | |
| Ctx.getCanonicalType(Friend.getCXXNameType())); | |
| default: | |
| return false; | |
| } | |
| } | |
| static bool MightInstantiateTo(ASTContext &Ctx, FunctionDecl *Context, | |
| FunctionDecl *Friend) { | |
| if (!MightInstantiateTo(Ctx, Context->getDeclName(), Friend->getDeclName())) | |
| return false; | |
| DeclContext *ContextDC = Context->getDeclContext(); | |
| DeclContext *FriendDC = Friend->getDeclContext(); | |
| if (!FriendDC->isDependentContext() && | |
| !MightInstantiateTo(ContextDC, FriendDC)) | |
| return false; | |
| CanQual<FunctionProtoType> FriendTy = GetCanonicalFunctionProto(Ctx, Friend); | |
| CanQual<FunctionProtoType> ContextTy = | |
| GetCanonicalFunctionProto(Ctx, Context); | |
| return MightInstantiateTo(ContextTy, FriendTy); | |
| } | |
| static bool MightInstantiateTo(ASTContext &Ctx, FunctionTemplateDecl *Context, | |
| FunctionTemplateDecl *Friend) { | |
| return MightInstantiateTo(Ctx, Context->getTemplatedDecl(), | |
| Friend->getTemplatedDecl()); | |
| } | |
| static AccessResult MatchesFriend(Sema &S, | |
| const EffectiveContext &EC, | |
| const CXXRecordDecl *Friend) { | |
| if (EC.includesClass(Friend)) | |
| return AR_accessible; | |
| if (EC.isDependent()) { | |
| for (const CXXRecordDecl *Context : EC.Records) { | |
| if (MightInstantiateTo(Context, Friend)) | |
| return AR_dependent; | |
| } | |
| } | |
| return AR_inaccessible; | |
| } | |
| static AccessResult MatchesFriend(Sema &S, | |
| const EffectiveContext &EC, | |
| CanQualType Friend) { | |
| if (const auto *RD = Friend->getAsCXXRecordDecl()) | |
| return MatchesFriend(S, EC, RD); | |
| // TODO: we can do better than this | |
| if (Friend->isDependentType()) | |
| return AR_dependent; | |
| return AR_inaccessible; | |
| } | |
| /// Determines whether the given friend class template matches | |
| /// anything in the effective context. | |
| static AccessResult MatchesFriend(Sema &S, | |
| const EffectiveContext &EC, | |
| ClassTemplateDecl *Friend) { | |
| AccessResult OnFailure = AR_inaccessible; | |
| // Check whether the friend is the template of a class in the | |
| // context chain. | |
| for (SmallVectorImpl<CXXRecordDecl*>::const_iterator | |
| I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) { | |
| CXXRecordDecl *Record = *I; | |
| // Figure out whether the current class has a template: | |
| ClassTemplateDecl *CTD; | |
| // A specialization of the template... | |
| if (isa<ClassTemplateSpecializationDecl>(Record)) { | |
| CTD = cast<ClassTemplateSpecializationDecl>(Record) | |
| ->getSpecializedTemplate(); | |
| // ... or the template pattern itself. | |
| } else { | |
| CTD = Record->getDescribedClassTemplate(); | |
| if (!CTD) continue; | |
| } | |
| // It's a match. | |
| if (declaresSameEntity(Friend, CTD)) | |
| return AR_accessible; | |
| // If the context isn't dependent, it can't be a dependent match. | |
| if (!EC.isDependent()) | |
| continue; | |
| // If the template names don't match, it can't be a dependent | |
| // match. | |
| if (CTD->getDeclName() != Friend->getDeclName()) | |
| continue; | |
| // If the class's context can't instantiate to the friend's | |
| // context, it can't be a dependent match. | |
| if (!MightInstantiateTo(CTD->getDeclContext(), Friend->getDeclContext())) | |
| continue; | |
| // Otherwise, it's a dependent match. | |
| OnFailure = AR_dependent; | |
| } | |
| return OnFailure; | |
| } | |
| /// Determines whether the given friend function matches anything in | |
| /// the effective context. | |
| static AccessResult MatchesFriend(Sema &S, | |
| const EffectiveContext &EC, | |
| FunctionDecl *Friend) { | |
| AccessResult OnFailure = AR_inaccessible; | |
| for (SmallVectorImpl<FunctionDecl*>::const_iterator | |
| I = EC.Functions.begin(), E = EC.Functions.end(); I != E; ++I) { | |
| if (Friend == *I) | |
| return AR_accessible; | |
| if (EC.isDependent() && MightInstantiateTo(S.Context, *I, Friend)) | |
| OnFailure = AR_dependent; | |
| } | |
| return OnFailure; | |
| } | |
| /// Determines whether the given friend function template matches | |
| /// anything in the effective context. | |
| static AccessResult MatchesFriend(Sema &S, | |
| const EffectiveContext &EC, | |
| FunctionTemplateDecl *Friend) { | |
| if (EC.Functions.empty()) return AR_inaccessible; | |
| AccessResult OnFailure = AR_inaccessible; | |
| for (SmallVectorImpl<FunctionDecl*>::const_iterator | |
| I = EC.Functions.begin(), E = EC.Functions.end(); I != E; ++I) { | |
| FunctionTemplateDecl *FTD = TryGetFunctionTemplateDecl(*I); | |
| if (!FTD) | |
| continue; | |
| if (Friend == FTD) | |
| return AR_accessible; | |
| if (EC.isDependent() && MightInstantiateTo(S.Context, FTD, Friend)) | |
| OnFailure = AR_dependent; | |
| } | |
| return OnFailure; | |
| } | |
| static AccessResult MatchesFriend(Sema &S, const EffectiveContext &EC, | |
| NamedDecl *ND) { | |
| ND = cast<NamedDecl>(ND->getCanonicalDecl()); | |
| if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(ND)) | |
| return MatchesFriend(S, EC, CTD); | |
| if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND)) | |
| return MatchesFriend(S, EC, FTD); | |
| if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(ND)) | |
| return MatchesFriend(S, EC, RD); | |
| assert(isa<FunctionDecl>(ND) && "unknown friend decl kind"); | |
| return MatchesFriend(S, EC, cast<FunctionDecl>(ND)); | |
| } | |
| static AccessResult MatchesFriend(Sema &S, FriendTemplateDecl *FTD, | |
| DeclarationName FriendName, | |
| TagTypeKind FriendTagKind, | |
| ClassTemplateDecl *ContextCTD, | |
| const TemplateSpecializationType *FriendTST, | |
| ArrayRef<TemplateParameterList *> TPLs, | |
| TemplateParameterList *MemberTPL, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| if (FriendName != ContextCTD->getDeclName()) | |
| return AR_inaccessible; | |
| if ((FriendTagKind == TagTypeKind::Union) != | |
| ContextCTD->getTemplatedDecl()->isUnion()) | |
| return AR_inaccessible; | |
| DeclContext *ContextDC = ContextCTD->getDeclContext(); | |
| AccessResult OnFailure = | |
| ContextDC->isDependentContext() ? AR_dependent : AR_inaccessible; | |
| FriendTemplateMatchContext FTMC(S, FTD); | |
| AccessResult Result = FTMC.deduce(ContextDC, FriendTST, TPLs, FailedTSC); | |
| if (!FTMC.hasDeducedArgs()) | |
| return Result; | |
| TemplateParameterList *InstTPL = SubstTemplateParameterList( | |
| S, MemberTPL, ContextDC, FTMC.getDeducedArgs()); | |
| if (!InstTPL || FTMC.hasErrorOccurred()) | |
| return OnFailure; | |
| Sema::TemplateCompareNewDeclInfo FriendInfo( | |
| ContextDC, FTD->getLexicalDeclContext(), FTD->getLocation()); | |
| if (S.TemplateParameterListsAreEqual( | |
| FriendInfo, InstTPL, ContextCTD, ContextCTD->getTemplateParameters(), | |
| /*Complain=*/false, Sema::TPL_TemplateMatch)) | |
| return AR_accessible; | |
| return OnFailure; | |
| } | |
| static AccessResult MatchesFriend(Sema &S, const EffectiveContext &EC, | |
| FriendTemplateDecl *FTD, | |
| ClassTemplateDecl *FriendCTD, | |
| NestedNameSpecifier Qualifier, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| const auto *FriendTST = | |
| GetQualifierClassTemplateSpecializationType(S.Context, Qualifier); | |
| if (!FriendTST) | |
| return MatchesFriend(S, EC, FriendCTD); | |
| ArrayRef<TemplateParameterList *> TPLs = FTD->getTemplateParameterLists(); | |
| AccessResult OnFailure = AR_inaccessible; | |
| for (CXXRecordDecl *ContextRD : EC.Records) { | |
| ClassTemplateDecl *ContextCTD = GetClassTemplateDecl(ContextRD); | |
| if (!ContextCTD) | |
| continue; | |
| AccessResult Result = | |
| MatchesFriend(S, FTD, FriendCTD->getDeclName(), | |
| FriendCTD->getTemplatedDecl()->getTagKind(), ContextCTD, | |
| FriendTST, TPLs.drop_back(), TPLs.back(), FailedTSC); | |
| if (Result == AR_accessible) | |
| return AR_accessible; | |
| if (Result == AR_dependent) | |
| OnFailure = AR_dependent; | |
| } | |
| return OnFailure; | |
| } | |
| static AccessResult MatchesFriend(Sema &S, const EffectiveContext &EC, | |
| FriendTemplateDecl *FTD, | |
| TemplateName FriendTemplate, | |
| ClassTemplateDecl *FriendCTD, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| NestedNameSpecifier Qualifier = FriendTemplate.getQualifier(); | |
| if (FriendTemplate.getAsUsingShadowDecl()) | |
| Qualifier = FriendCTD->getTemplatedDecl()->getQualifier(); | |
| return MatchesFriend(S, EC, FTD, FriendCTD, Qualifier, FailedTSC); | |
| } | |
| static AccessResult MatchesFriend(Sema &S, const EffectiveContext &EC, | |
| FriendTemplateDecl *FTD, | |
| ClassTemplateDecl *FriendCTD, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| return MatchesFriend(S, EC, FTD, FriendCTD, | |
| FriendCTD->getTemplatedDecl()->getQualifier(), | |
| FailedTSC); | |
| } | |
| static AccessResult MatchesFriend(Sema &S, FriendTemplateDecl *FTD, | |
| FunctionDecl *FriendFD, | |
| FunctionDecl *ContextFD, | |
| const TemplateSpecializationType *FriendTST, | |
| ArrayRef<TemplateParameterList *> TPLs, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| if (!MightInstantiateTo(S.Context, ContextFD->getDeclName(), | |
| FriendFD->getDeclName())) | |
| return AR_inaccessible; | |
| FunctionTemplateDecl *FriendTemplate = | |
| FriendFD->getDescribedFunctionTemplate(); | |
| FunctionTemplateDecl *ContextTemplate = TryGetFunctionTemplateDecl(ContextFD); | |
| if (FriendTemplate && !ContextTemplate) | |
| return AR_inaccessible; | |
| DeclContext *ContextDC = ContextFD->getDeclContext(); | |
| AccessResult OnFailure = | |
| ContextDC->isDependentContext() ? AR_dependent : AR_inaccessible; | |
| FriendTemplateMatchContext FTMC(S, FTD); | |
| AccessResult Result = FTMC.deduce(ContextDC, FriendTST, TPLs, FailedTSC); | |
| if (!FTMC.hasDeducedArgs()) | |
| return Result; | |
| Sema::TemplateCompareNewDeclInfo FriendInfo( | |
| ContextDC, FTD->getLexicalDeclContext(), FTD->getLocation()); | |
| if (FriendTemplate) { | |
| TemplateParameterList *InstTPL = | |
| SubstTemplateParameterList(S, FriendTemplate->getTemplateParameters(), | |
| ContextDC, FTMC.getDeducedArgs()); | |
| if (!InstTPL || !S.TemplateParameterListsAreEqual( | |
| FriendInfo, InstTPL, ContextTemplate, | |
| ContextTemplate->getTemplateParameters(), | |
| /*Complain=*/false, Sema::TPL_TemplateMatch)) | |
| return OnFailure; | |
| ContextFD = ContextTemplate->getTemplatedDecl(); | |
| } | |
| Sema::ContextRAII SavedContext(S, FTD->getDeclContext()); | |
| QualType InstFriendType = | |
| S.SubstType(FriendFD->getType(), FTMC.getDeducedArgs(), | |
| FriendFD->getLocation(), FriendFD->getDeclName()); | |
| SavedContext.pop(); | |
| if (InstFriendType.isNull() || FTMC.hasErrorOccurred()) | |
| return OnFailure; | |
| if (ContextTemplate && !FriendTemplate) { | |
| AccessResult OnSpecializationFailure = | |
| ContextFD->isDependentContext() ? AR_dependent : OnFailure; | |
| const ASTTemplateArgumentListInfo *ArgsWritten = | |
| FriendFD->getTemplateSpecializationArgsAsWritten(); | |
| TemplateArgumentListInfo InstArgs; | |
| if (ArgsWritten) { | |
| InstArgs.setLAngleLoc(ArgsWritten->getLAngleLoc()); | |
| InstArgs.setRAngleLoc(ArgsWritten->getRAngleLoc()); | |
| if (S.SubstTemplateArguments(ArgsWritten->arguments(), | |
| FTMC.getDeducedArgs(), InstArgs)) | |
| return OnSpecializationFailure; | |
| } | |
| FunctionDecl *ContextSpecialization = nullptr; | |
| TemplateDeductionInfo FunctionInfo(FTD->getLocation()); | |
| if (S.DeduceTemplateArguments( | |
| ContextTemplate, ArgsWritten ? &InstArgs : nullptr, InstFriendType, | |
| ContextSpecialization, | |
| FunctionInfo) != TemplateDeductionResult::Success || | |
| !ContextSpecialization || FTMC.hasErrorOccurred() || | |
| !declaresSameEntity(ContextSpecialization, ContextFD)) | |
| return OnSpecializationFailure; | |
| ContextFD = ContextSpecialization; | |
| } | |
| if (!HasSameFunctionType(S, InstFriendType, ContextFD->getType(), | |
| FTD->getLocation()) || | |
| FTMC.hasErrorOccurred()) | |
| return OnFailure; | |
| if (!FriendTemplate) | |
| return AR_accessible; | |
| AssociatedConstraint FriendRequiresClause = | |
| FriendFD->getTrailingRequiresClause(); | |
| AssociatedConstraint ContextRequiresClause = | |
| ContextFD->getTrailingRequiresClause(); | |
| if (FriendRequiresClause.isNull() != ContextRequiresClause.isNull()) | |
| return AR_inaccessible; | |
| if (!FriendRequiresClause) | |
| return AR_accessible; | |
| ExprResult InstFriendRequiresClause = | |
| S.SubstConstraintExprWithoutSatisfaction( | |
| const_cast<Expr *>(FriendRequiresClause.ConstraintExpr), | |
| FTMC.getDeducedArgs()); | |
| if (!InstFriendRequiresClause.isUsable()) | |
| return OnFailure; | |
| if (!S.AreConstraintExpressionsEqual( | |
| ContextFD, ContextRequiresClause.ConstraintExpr, FriendInfo, | |
| InstFriendRequiresClause.get())) | |
| return OnFailure; | |
| return FTMC.hasErrorOccurred() ? AR_inaccessible : AR_accessible; | |
| } | |
| static AccessResult MatchesFriend(Sema &S, const EffectiveContext &EC, | |
| FriendTemplateDecl *FTD, | |
| FunctionDecl *FriendFD, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| const auto *FriendTST = GetQualifierClassTemplateSpecializationType( | |
| S.Context, FriendFD->getQualifier()); | |
| if (!FriendTST) | |
| return AR_inaccessible; | |
| ArrayRef<TemplateParameterList *> TPLs = FTD->getTemplateParameterLists(); | |
| AccessResult OnFailure = AR_inaccessible; | |
| for (FunctionDecl *ContextFD : EC.Functions) { | |
| AccessResult Result = | |
| MatchesFriend(S, FTD, FriendFD, ContextFD, FriendTST, TPLs, FailedTSC); | |
| if (Result == AR_accessible) | |
| return AR_accessible; | |
| if (Result == AR_dependent) | |
| OnFailure = AR_dependent; | |
| } | |
| return OnFailure; | |
| } | |
| static AccessResult MatchesFriend(Sema &S, const EffectiveContext &EC, | |
| FriendTemplateDecl *FTD, NamedDecl *Friend, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| TemplateName FriendTemplate = FTD->getFriendTemplateName(); | |
| if (auto *FriendCTD = dyn_cast_if_present<ClassTemplateDecl>( | |
| FriendTemplate.getAsTemplateDecl())) | |
| return MatchesFriend(S, EC, FTD, FriendTemplate, FriendCTD, FailedTSC); | |
| if (auto *FriendCTD = dyn_cast<ClassTemplateDecl>(Friend)) | |
| return MatchesFriend(S, EC, FTD, FriendCTD, FailedTSC); | |
| if (FunctionDecl *FriendFD = Friend->getAsFunction()) | |
| return MatchesFriend(S, EC, FTD, FriendFD, FailedTSC); | |
| return MatchesFriend(S, EC, Friend); | |
| } | |
| static AccessResult MatchesFriend(Sema &S, const EffectiveContext &EC, | |
| FriendTemplateDecl *FTD, | |
| TypeSourceInfo *FriendTSI, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| QualType FriendType = FriendTSI->getType(); | |
| if (!FriendType->isDependentType()) | |
| return MatchesFriend(S, EC, S.Context.getCanonicalType(FriendType)); | |
| AccessResult OnFailure = AR_inaccessible; | |
| if (auto FriendTSTL = | |
| FriendTSI->getTypeLoc().getAs<TemplateSpecializationTypeLoc>()) { | |
| const auto *FriendTST = FriendTSTL.getTypePtr(); | |
| const auto *FriendQTST = GetQualifierClassTemplateSpecializationType( | |
| S.Context, FriendTSTL.getQualifierLoc().getNestedNameSpecifier()); | |
| if (!FriendQTST) | |
| return OnFailure; | |
| ArrayRef<TemplateParameterList *> TPLs = FTD->getTemplateParameterLists(); | |
| TemplateName FriendTemplate = FriendTST->getTemplateName(); | |
| DeclarationName FriendName; | |
| if (TemplateDecl *TD = FriendTemplate.getAsTemplateDecl()) | |
| FriendName = TD->getDeclName(); | |
| else if (DependentTemplateName *DTN = | |
| FriendTemplate.getAsDependentTemplateName()) | |
| FriendName = DTN->getName().getIdentifier(); | |
| TagTypeKind FriendTagKind = | |
| TypeWithKeyword::getTagTypeKindForKeyword(FriendTST->getKeyword()); | |
| for (CXXRecordDecl *ContextRD : EC.Records) { | |
| ClassTemplateDecl *ContextCTD = GetClassTemplateDecl(ContextRD); | |
| if (!ContextCTD) | |
| continue; | |
| if (FriendName && ContextCTD->getDeclName() != FriendName) | |
| continue; | |
| if ((FriendTagKind == TagTypeKind::Union) != | |
| ContextCTD->getTemplatedDecl()->isUnion()) | |
| continue; | |
| FriendTemplateMatchContext FTMC(S, FTD); | |
| AccessResult Result = | |
| FTMC.deduce(ContextRD->getDeclContext(), FriendQTST, TPLs, FailedTSC); | |
| if (!FTMC.hasDeducedArgs()) { | |
| if (Result == AR_dependent) | |
| OnFailure = AR_dependent; | |
| continue; | |
| } | |
| TypeSourceInfo *InstFriendTSI = | |
| S.SubstFriendType(FriendTSI, FTMC.getDeducedArgs(), | |
| FTD->getLocation(), DeclarationName()); | |
| if (InstFriendTSI && !FTMC.hasErrorOccurred() && | |
| S.Context.hasSameType(InstFriendTSI->getType(), | |
| S.Context.getCanonicalTagType(ContextRD))) | |
| return AR_accessible; | |
| if (ContextRD->isDependentContext()) | |
| OnFailure = AR_dependent; | |
| } | |
| return OnFailure; | |
| } | |
| const auto *FriendDNT = FriendType->getAs<DependentNameType>(); | |
| if (!FriendDNT) | |
| return OnFailure; | |
| const auto *FriendTST = GetQualifierClassTemplateSpecializationType( | |
| S.Context, FriendDNT->getQualifier()); | |
| if (!FriendTST) | |
| return OnFailure; | |
| ArrayRef<TemplateParameterList *> TPLs = FTD->getTemplateParameterLists(); | |
| TagTypeKind FriendTagKind = | |
| TypeWithKeyword::getTagTypeKindForKeyword(FriendDNT->getKeyword()); | |
| for (CXXRecordDecl *ContextRD : EC.Records) { | |
| if (ContextRD->getDeclName() != FriendDNT->getIdentifier()) | |
| continue; | |
| if (ClassTemplateDecl *ContextCTD = GetClassTemplateDecl(ContextRD)) { | |
| if (FTD->getFriendTemplateName().isNull()) { | |
| if (FailedTSC) { | |
| MultiLevelTemplateArgumentList DeducedArgs; | |
| DeduceTemplateArguments(S, FTD, ContextCTD->getDeclContext(), | |
| FriendTST, TPLs, FailedTSC, DeducedArgs); | |
| } | |
| continue; | |
| } | |
| AccessResult Result = MatchesFriend( | |
| S, FTD, FriendDNT->getIdentifier(), FriendTagKind, ContextCTD, | |
| FriendTST, TPLs.drop_back(), TPLs.back(), FailedTSC); | |
| if (Result == AR_accessible) | |
| return AR_accessible; | |
| if (Result == AR_dependent) | |
| OnFailure = AR_dependent; | |
| continue; | |
| } | |
| if (!FTD->getFriendTemplateName().isNull()) | |
| continue; | |
| if ((FriendTagKind == TagTypeKind::Union) != ContextRD->isUnion()) | |
| continue; | |
| MultiLevelTemplateArgumentList DeducedArgs; | |
| AccessResult Result = | |
| DeduceTemplateArguments(S, FTD, ContextRD->getDeclContext(), FriendTST, | |
| TPLs, FailedTSC, DeducedArgs); | |
| if (Result == AR_accessible) | |
| return AR_accessible; | |
| if (Result == AR_dependent) | |
| OnFailure = AR_dependent; | |
| } | |
| return OnFailure; | |
| } | |
| /// Determines whether the given friend declaration matches anything | |
| /// in the effective context. | |
| static AccessResult MatchesFriend(Sema &S, | |
| const EffectiveContext &EC, | |
| FriendDecl *FriendD) { | |
| // Whitelist accesses if there's an invalid friend declaration. | |
| if (FriendD->isInvalidDecl()) | |
| return AR_accessible; | |
| if (NamedDecl *Friend = FriendD->getFriendDecl()) | |
| return MatchesFriend(S, EC, Friend); | |
| if (TypeSourceInfo *T = FriendD->getFriendType()) | |
| return MatchesFriend(S, EC, T->getType()->getCanonicalTypeUnqualified()); | |
| return AR_inaccessible; | |
| } | |
| static AccessResult MatchesFriend(Sema &S, const EffectiveContext &EC, | |
| FriendTemplateDecl *FTD, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| if (FTD->isInvalidDecl()) | |
| return AR_accessible; | |
| if (TypeSourceInfo *TSI = FTD->getFriendType()) | |
| return MatchesFriend(S, EC, FTD, TSI, FailedTSC); | |
| NamedDecl *Friend = FTD->getFriendDecl(); | |
| assert(Friend && "friend template must name a type or declaration"); | |
| return MatchesFriend(S, EC, FTD, Friend, FailedTSC); | |
| } | |
| static AccessResult GetFriendKind(Sema &S, const EffectiveContext &EC, | |
| const CXXRecordDecl *Class, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| AccessResult OnFailure = AR_inaccessible; | |
| // Okay, check friends. | |
| for (FriendDecl *Friend : Class->friends()) { | |
| AccessResult AR; | |
| if (auto *FTD = dyn_cast<FriendTemplateDecl>(Friend)) | |
| AR = MatchesFriend(S, EC, FTD, FailedTSC); | |
| else | |
| AR = MatchesFriend(S, EC, Friend); | |
| switch (AR) { | |
| case AR_accessible: | |
| return AR_accessible; | |
| case AR_inaccessible: | |
| continue; | |
| case AR_dependent: | |
| OnFailure = AR_dependent; | |
| break; | |
| } | |
| } | |
| // That's it, give up. | |
| return OnFailure; | |
| } | |
| namespace { | |
| /// A helper class for checking for a friend which will grant access | |
| /// to a protected instance member. | |
| struct ProtectedFriendContext { | |
| Sema &S; | |
| const EffectiveContext &EC; | |
| TemplateSpecCandidateSet *FailedTSC; | |
| const CXXRecordDecl *NamingClass; | |
| bool CheckDependent; | |
| bool EverDependent; | |
| /// The path down to the current base class. | |
| SmallVector<const CXXRecordDecl*, 20> CurPath; | |
| ProtectedFriendContext(Sema &S, const EffectiveContext &EC, | |
| const CXXRecordDecl *InstanceContext, | |
| const CXXRecordDecl *NamingClass, | |
| TemplateSpecCandidateSet *FailedTSC) | |
| : S(S), EC(EC), FailedTSC(FailedTSC), NamingClass(NamingClass), | |
| CheckDependent(InstanceContext->isDependentContext() || | |
| NamingClass->isDependentContext()), | |
| EverDependent(false) {} | |
| /// Check classes in the current path for friendship, starting at | |
| /// the given index. | |
| bool checkFriendshipAlongPath(unsigned I) { | |
| assert(I < CurPath.size()); | |
| for (unsigned E = CurPath.size(); I != E; ++I) { | |
| switch (GetFriendKind(S, EC, CurPath[I], FailedTSC)) { | |
| case AR_accessible: return true; | |
| case AR_inaccessible: continue; | |
| case AR_dependent: EverDependent = true; continue; | |
| } | |
| } | |
| return false; | |
| } | |
| /// Perform a search starting at the given class. | |
| /// | |
| /// PrivateDepth is the index of the last (least derived) class | |
| /// along the current path such that a notional public member of | |
| /// the final class in the path would have access in that class. | |
| bool findFriendship(const CXXRecordDecl *Cur, unsigned PrivateDepth) { | |
| // If we ever reach the naming class, check the current path for | |
| // friendship. We can also stop recursing because we obviously | |
| // won't find the naming class there again. | |
| if (Cur == NamingClass) | |
| return checkFriendshipAlongPath(PrivateDepth); | |
| if (CheckDependent && MightInstantiateTo(Cur, NamingClass)) | |
| EverDependent = true; | |
| // Recurse into the base classes. | |
| for (const auto &I : Cur->bases()) { | |
| // If this is private inheritance, then a public member of the | |
| // base will not have any access in classes derived from Cur. | |
| unsigned BasePrivateDepth = PrivateDepth; | |
| if (I.getAccessSpecifier() == AS_private) | |
| BasePrivateDepth = CurPath.size() - 1; | |
| const CXXRecordDecl *RD; | |
| QualType T = I.getType(); | |
| if (CXXRecordDecl *Rec = T->getAsCXXRecordDecl()) { | |
| RD = Rec; | |
| } else { | |
| assert(T->isDependentType() && "non-dependent base wasn't a record?"); | |
| EverDependent = true; | |
| continue; | |
| } | |
| // Recurse. We don't need to clean up if this returns true. | |
| CurPath.push_back(RD); | |
| if (findFriendship(RD->getCanonicalDecl(), BasePrivateDepth)) | |
| return true; | |
| CurPath.pop_back(); | |
| } | |
| return false; | |
| } | |
| bool findFriendship(const CXXRecordDecl *Cur) { | |
| assert(CurPath.empty()); | |
| CurPath.push_back(Cur); | |
| return findFriendship(Cur, 0); | |
| } | |
| }; | |
| } | |
| /// Search for a class P that EC is a friend of, under the constraint | |
| /// InstanceContext <= P | |
| /// if InstanceContext exists, or else | |
| /// NamingClass <= P | |
| /// and with the additional restriction that a protected member of | |
| /// NamingClass would have some natural access in P, which implicitly | |
| /// imposes the constraint that P <= NamingClass. | |
| /// | |
| /// This isn't quite the condition laid out in the standard. | |
| /// Instead of saying that a notional protected member of NamingClass | |
| /// would have to have some natural access in P, it says the actual | |
| /// target has to have some natural access in P, which opens up the | |
| /// possibility that the target (which is not necessarily a member | |
| /// of NamingClass) might be more accessible along some path not | |
| /// passing through it. That's really a bad idea, though, because it | |
| /// introduces two problems: | |
| /// - Most importantly, it breaks encapsulation because you can | |
| /// access a forbidden base class's members by directly subclassing | |
| /// it elsewhere. | |
| /// - It also makes access substantially harder to compute because it | |
| /// breaks the hill-climbing algorithm: knowing that the target is | |
| /// accessible in some base class would no longer let you change | |
| /// the question solely to whether the base class is accessible, | |
| /// because the original target might have been more accessible | |
| /// because of crazy subclassing. | |
| /// So we don't implement that. | |
| static AccessResult GetProtectedFriendKind( | |
| Sema &S, const EffectiveContext &EC, const CXXRecordDecl *InstanceContext, | |
| const CXXRecordDecl *NamingClass, TemplateSpecCandidateSet *FailedTSC) { | |
| assert(InstanceContext == nullptr || | |
| InstanceContext->getCanonicalDecl() == InstanceContext); | |
| assert(NamingClass->getCanonicalDecl() == NamingClass); | |
| // If we don't have an instance context, our constraints give us | |
| // that NamingClass <= P <= NamingClass, i.e. P == NamingClass. | |
| // This is just the usual friendship check. | |
| if (!InstanceContext) | |
| return GetFriendKind(S, EC, NamingClass, FailedTSC); | |
| ProtectedFriendContext PRC(S, EC, InstanceContext, NamingClass, FailedTSC); | |
| if (PRC.findFriendship(InstanceContext)) return AR_accessible; | |
| if (PRC.EverDependent) return AR_dependent; | |
| return AR_inaccessible; | |
| } | |
| static AccessResult HasAccess(Sema &S, const EffectiveContext &EC, | |
| const CXXRecordDecl *NamingClass, | |
| AccessSpecifier Access, | |
| const AccessTarget &Target, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| assert(NamingClass->getCanonicalDecl() == NamingClass && | |
| "declaration should be canonicalized before being passed here"); | |
| if (Access == AS_public) return AR_accessible; | |
| assert(Access == AS_private || Access == AS_protected); | |
| AccessResult OnFailure = AR_inaccessible; | |
| for (EffectiveContext::record_iterator | |
| I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) { | |
| // All the declarations in EC have been canonicalized, so pointer | |
| // equality from this point on will work fine. | |
| const CXXRecordDecl *ECRecord = *I; | |
| // [B2] and [M2] | |
| if (Access == AS_private) { | |
| if (ECRecord == NamingClass) | |
| return AR_accessible; | |
| if (EC.isDependent() && MightInstantiateTo(ECRecord, NamingClass)) | |
| OnFailure = AR_dependent; | |
| // [B3] and [M3] | |
| } else { | |
| assert(Access == AS_protected); | |
| switch (IsDerivedFromInclusive(ECRecord, NamingClass)) { | |
| case AR_accessible: break; | |
| case AR_inaccessible: continue; | |
| case AR_dependent: OnFailure = AR_dependent; continue; | |
| } | |
| // C++ [class.protected]p1: | |
| // An additional access check beyond those described earlier in | |
| // [class.access] is applied when a non-static data member or | |
| // non-static member function is a protected member of its naming | |
| // class. As described earlier, access to a protected member is | |
| // granted because the reference occurs in a friend or member of | |
| // some class C. If the access is to form a pointer to member, | |
| // the nested-name-specifier shall name C or a class derived from | |
| // C. All other accesses involve a (possibly implicit) object | |
| // expression. In this case, the class of the object expression | |
| // shall be C or a class derived from C. | |
| // | |
| // We interpret this as a restriction on [M3]. | |
| // In this part of the code, 'C' is just our context class ECRecord. | |
| // These rules are different if we don't have an instance context. | |
| if (!Target.hasInstanceContext()) { | |
| // If it's not an instance member, these restrictions don't apply. | |
| if (!Target.isInstanceMember()) return AR_accessible; | |
| // If it's an instance member, use the pointer-to-member rule | |
| // that the naming class has to be derived from the effective | |
| // context. | |
| // Emulate a MSVC bug where the creation of pointer-to-member | |
| // to protected member of base class is allowed but only from | |
| // static member functions. | |
| if (S.getLangOpts().MSVCCompat && !EC.Functions.empty()) | |
| if (CXXMethodDecl* MD = dyn_cast<CXXMethodDecl>(EC.Functions.front())) | |
| if (MD->isStatic()) return AR_accessible; | |
| // Despite the standard's confident wording, there is a case | |
| // where you can have an instance member that's neither in a | |
| // pointer-to-member expression nor in a member access: when | |
| // it names a field in an unevaluated context that can't be an | |
| // implicit member. Pending clarification, we just apply the | |
| // same naming-class restriction here. | |
| // FIXME: we're probably not correctly adding the | |
| // protected-member restriction when we retroactively convert | |
| // an expression to being evaluated. | |
| // We know that ECRecord derives from NamingClass. The | |
| // restriction says to check whether NamingClass derives from | |
| // ECRecord, but that's not really necessary: two distinct | |
| // classes can't be recursively derived from each other. So | |
| // along this path, we just need to check whether the classes | |
| // are equal. | |
| if (NamingClass == ECRecord) return AR_accessible; | |
| // Otherwise, this context class tells us nothing; on to the next. | |
| continue; | |
| } | |
| assert(Target.isInstanceMember()); | |
| const CXXRecordDecl *InstanceContext = Target.resolveInstanceContext(S); | |
| if (!InstanceContext) { | |
| OnFailure = AR_dependent; | |
| continue; | |
| } | |
| switch (IsDerivedFromInclusive(InstanceContext, ECRecord)) { | |
| case AR_accessible: return AR_accessible; | |
| case AR_inaccessible: continue; | |
| case AR_dependent: OnFailure = AR_dependent; continue; | |
| } | |
| } | |
| } | |
| // [M3] and [B3] say that, if the target is protected in N, we grant | |
| // access if the access occurs in a friend or member of some class P | |
| // that's a subclass of N and where the target has some natural | |
| // access in P. The 'member' aspect is easy to handle because P | |
| // would necessarily be one of the effective-context records, and we | |
| // address that above. The 'friend' aspect is completely ridiculous | |
| // to implement because there are no restrictions at all on P | |
| // *unless* the [class.protected] restriction applies. If it does, | |
| // however, we should ignore whether the naming class is a friend, | |
| // and instead rely on whether any potential P is a friend. | |
| if (Access == AS_protected && Target.isInstanceMember()) { | |
| // Compute the instance context if possible. | |
| const CXXRecordDecl *InstanceContext = nullptr; | |
| if (Target.hasInstanceContext()) { | |
| InstanceContext = Target.resolveInstanceContext(S); | |
| if (!InstanceContext) return AR_dependent; | |
| } | |
| switch (GetProtectedFriendKind(S, EC, InstanceContext, NamingClass, | |
| FailedTSC)) { | |
| case AR_accessible: return AR_accessible; | |
| case AR_inaccessible: return OnFailure; | |
| case AR_dependent: return AR_dependent; | |
| } | |
| llvm_unreachable("impossible friendship kind"); | |
| } | |
| switch (GetFriendKind(S, EC, NamingClass, FailedTSC)) { | |
| case AR_accessible: return AR_accessible; | |
| case AR_inaccessible: return OnFailure; | |
| case AR_dependent: return AR_dependent; | |
| } | |
| // Silence bogus warnings | |
| llvm_unreachable("impossible friendship kind"); | |
| } | |
| /// Finds the best path from the naming class to the declaring class, | |
| /// taking friend declarations into account. | |
| /// | |
| /// C++0x [class.access.base]p5: | |
| /// A member m is accessible at the point R when named in class N if | |
| /// [M1] m as a member of N is public, or | |
| /// [M2] m as a member of N is private, and R occurs in a member or | |
| /// friend of class N, or | |
| /// [M3] m as a member of N is protected, and R occurs in a member or | |
| /// friend of class N, or in a member or friend of a class P | |
| /// derived from N, where m as a member of P is public, private, | |
| /// or protected, or | |
| /// [M4] there exists a base class B of N that is accessible at R, and | |
| /// m is accessible at R when named in class B. | |
| /// | |
| /// C++0x [class.access.base]p4: | |
| /// A base class B of N is accessible at R, if | |
| /// [B1] an invented public member of B would be a public member of N, or | |
| /// [B2] R occurs in a member or friend of class N, and an invented public | |
| /// member of B would be a private or protected member of N, or | |
| /// [B3] R occurs in a member or friend of a class P derived from N, and an | |
| /// invented public member of B would be a private or protected member | |
| /// of P, or | |
| /// [B4] there exists a class S such that B is a base class of S accessible | |
| /// at R and S is a base class of N accessible at R. | |
| /// | |
| /// Along a single inheritance path we can restate both of these | |
| /// iteratively: | |
| /// | |
| /// First, we note that M1-4 are equivalent to B1-4 if the member is | |
| /// treated as a notional base of its declaring class with inheritance | |
| /// access equivalent to the member's access. Therefore we need only | |
| /// ask whether a class B is accessible from a class N in context R. | |
| /// | |
| /// Let B_1 .. B_n be the inheritance path in question (i.e. where | |
| /// B_1 = N, B_n = B, and for all i, B_{i+1} is a direct base class of | |
| /// B_i). For i in 1..n, we will calculate ACAB(i), the access to the | |
| /// closest accessible base in the path: | |
| /// Access(a, b) = (* access on the base specifier from a to b *) | |
| /// Merge(a, forbidden) = forbidden | |
| /// Merge(a, private) = forbidden | |
| /// Merge(a, b) = min(a,b) | |
| /// Accessible(c, forbidden) = false | |
| /// Accessible(c, private) = (R is c) || IsFriend(c, R) | |
| /// Accessible(c, protected) = (R derived from c) || IsFriend(c, R) | |
| /// Accessible(c, public) = true | |
| /// ACAB(n) = public | |
| /// ACAB(i) = | |
| /// let AccessToBase = Merge(Access(B_i, B_{i+1}), ACAB(i+1)) in | |
| /// if Accessible(B_i, AccessToBase) then public else AccessToBase | |
| /// | |
| /// B is an accessible base of N at R iff ACAB(1) = public. | |
| /// | |
| /// \param FinalAccess the access of the "final step", or AS_public if | |
| /// there is no final step. | |
| /// \return null if friendship is dependent | |
| static CXXBasePath *FindBestPath(Sema &S, | |
| const EffectiveContext &EC, | |
| AccessTarget &Target, | |
| AccessSpecifier FinalAccess, | |
| CXXBasePaths &Paths) { | |
| // Derive the paths to the desired base. | |
| const CXXRecordDecl *Derived = Target.getNamingClass(); | |
| const CXXRecordDecl *Base = Target.getDeclaringClass(); | |
| // FIXME: fail correctly when there are dependent paths. | |
| bool isDerived = Derived->isDerivedFrom(const_cast<CXXRecordDecl*>(Base), | |
| Paths); | |
| assert(isDerived && "derived class not actually derived from base"); | |
| (void) isDerived; | |
| CXXBasePath *BestPath = nullptr; | |
| assert(FinalAccess != AS_none && "forbidden access after declaring class"); | |
| bool AnyDependent = false; | |
| // Derive the friend-modified access along each path. | |
| for (CXXBasePaths::paths_iterator PI = Paths.begin(), PE = Paths.end(); | |
| PI != PE; ++PI) { | |
| AccessTarget::SavedInstanceContext _ = Target.saveInstanceContext(); | |
| // Walk through the path backwards. | |
| AccessSpecifier PathAccess = FinalAccess; | |
| CXXBasePath::iterator I = PI->end(), E = PI->begin(); | |
| while (I != E) { | |
| --I; | |
| assert(PathAccess != AS_none); | |
| // If the declaration is a private member of a base class, there | |
| // is no level of friendship in derived classes that can make it | |
| // accessible. | |
| if (PathAccess == AS_private) { | |
| PathAccess = AS_none; | |
| break; | |
| } | |
| const CXXRecordDecl *NC = I->Class->getCanonicalDecl(); | |
| AccessSpecifier BaseAccess = I->Base->getAccessSpecifier(); | |
| PathAccess = std::max(PathAccess, BaseAccess); | |
| switch (HasAccess(S, EC, NC, PathAccess, Target, | |
| /*FailedTSC=*/nullptr)) { | |
| case AR_inaccessible: break; | |
| case AR_accessible: | |
| PathAccess = AS_public; | |
| // Future tests are not against members and so do not have | |
| // instance context. | |
| Target.suppressInstanceContext(); | |
| break; | |
| case AR_dependent: | |
| AnyDependent = true; | |
| goto Next; | |
| } | |
| } | |
| // Note that we modify the path's Access field to the | |
| // friend-modified access. | |
| if (BestPath == nullptr || PathAccess < BestPath->Access) { | |
| BestPath = &*PI; | |
| BestPath->Access = PathAccess; | |
| // Short-circuit if we found a public path. | |
| if (BestPath->Access == AS_public) | |
| return BestPath; | |
| } | |
| Next: ; | |
| } | |
| assert((!BestPath || BestPath->Access != AS_public) && | |
| "fell out of loop with public path"); | |
| // We didn't find a public path, but at least one path was subject | |
| // to dependent friendship, so delay the check. | |
| if (AnyDependent) | |
| return nullptr; | |
| return BestPath; | |
| } | |
| /// Given that an entity has protected natural access, check whether | |
| /// access might be denied because of the protected member access | |
| /// restriction. | |
| /// | |
| /// \return true if a note was emitted | |
| static bool TryDiagnoseProtectedAccess(Sema &S, const EffectiveContext &EC, | |
| AccessTarget &Target) { | |
| // Only applies to instance accesses. | |
| if (!Target.isInstanceMember()) | |
| return false; | |
| assert(Target.isMemberAccess()); | |
| const CXXRecordDecl *NamingClass = Target.getEffectiveNamingClass(); | |
| for (EffectiveContext::record_iterator | |
| I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) { | |
| const CXXRecordDecl *ECRecord = *I; | |
| switch (IsDerivedFromInclusive(ECRecord, NamingClass)) { | |
| case AR_accessible: break; | |
| case AR_inaccessible: continue; | |
| case AR_dependent: continue; | |
| } | |
| // The effective context is a subclass of the declaring class. | |
| // Check whether the [class.protected] restriction is limiting | |
| // access. | |
| // To get this exactly right, this might need to be checked more | |
| // holistically; it's not necessarily the case that gaining | |
| // access here would grant us access overall. | |
| NamedDecl *D = Target.getTargetDecl(); | |
| // If we don't have an instance context, [class.protected] says the | |
| // naming class has to equal the context class. | |
| if (!Target.hasInstanceContext()) { | |
| // If it does, the restriction doesn't apply. | |
| if (NamingClass == ECRecord) continue; | |
| // TODO: it would be great to have a fixit here, since this is | |
| // such an obvious error. | |
| S.Diag(D->getLocation(), diag::note_access_protected_restricted_noobject) | |
| << S.Context.getCanonicalTagType(ECRecord); | |
| return true; | |
| } | |
| const CXXRecordDecl *InstanceContext = Target.resolveInstanceContext(S); | |
| assert(InstanceContext && "diagnosing dependent access"); | |
| switch (IsDerivedFromInclusive(InstanceContext, ECRecord)) { | |
| case AR_accessible: continue; | |
| case AR_dependent: continue; | |
| case AR_inaccessible: | |
| break; | |
| } | |
| // Okay, the restriction seems to be what's limiting us. | |
| // Use a special diagnostic for constructors and destructors. | |
| if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D) || | |
| (isa<FunctionTemplateDecl>(D) && | |
| isa<CXXConstructorDecl>( | |
| cast<FunctionTemplateDecl>(D)->getTemplatedDecl()))) { | |
| return S.Diag(D->getLocation(), | |
| diag::note_access_protected_restricted_ctordtor) | |
| << isa<CXXDestructorDecl>(D->getAsFunction()); | |
| } | |
| // Otherwise, use the generic diagnostic. | |
| return S.Diag(D->getLocation(), | |
| diag::note_access_protected_restricted_object) | |
| << S.Context.getCanonicalTagType(ECRecord); | |
| } | |
| return false; | |
| } | |
| /// We are unable to access a given declaration due to its direct | |
| /// access control; diagnose that. | |
| static void diagnoseBadDirectAccess(Sema &S, | |
| const EffectiveContext &EC, | |
| AccessTarget &entity) { | |
| assert(entity.isMemberAccess()); | |
| NamedDecl *D = entity.getTargetDecl(); | |
| if (D->getAccess() == AS_protected && | |
| TryDiagnoseProtectedAccess(S, EC, entity)) | |
| return; | |
| // Find an original declaration. | |
| while (D->isOutOfLine()) { | |
| NamedDecl *PrevDecl = nullptr; | |
| if (VarDecl *VD = dyn_cast<VarDecl>(D)) | |
| PrevDecl = VD->getPreviousDecl(); | |
| else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) | |
| PrevDecl = FD->getPreviousDecl(); | |
| else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(D)) | |
| PrevDecl = TND->getPreviousDecl(); | |
| else if (TagDecl *TD = dyn_cast<TagDecl>(D)) { | |
| if (const auto *RD = dyn_cast<CXXRecordDecl>(TD); | |
| RD && RD->isInjectedClassName()) | |
| break; | |
| PrevDecl = TD->getPreviousDecl(); | |
| } | |
| if (!PrevDecl) break; | |
| D = PrevDecl; | |
| } | |
| CXXRecordDecl *DeclaringClass = FindDeclaringClass(D); | |
| Decl *ImmediateChild; | |
| if (D->getDeclContext() == DeclaringClass) | |
| ImmediateChild = D; | |
| else { | |
| DeclContext *DC = D->getDeclContext(); | |
| while (DC->getParent() != DeclaringClass) | |
| DC = DC->getParent(); | |
| ImmediateChild = cast<Decl>(DC); | |
| } | |
| // Check whether there's an AccessSpecDecl preceding this in the | |
| // chain of the DeclContext. | |
| bool isImplicit = true; | |
| for (const auto *I : DeclaringClass->decls()) { | |
| if (I == ImmediateChild) break; | |
| if (isa<AccessSpecDecl>(I)) { | |
| isImplicit = false; | |
| break; | |
| } | |
| } | |
| S.Diag(D->getLocation(), diag::note_access_natural) | |
| << (unsigned) (D->getAccess() == AS_protected) | |
| << isImplicit; | |
| } | |
| /// Diagnose the path which caused the given declaration or base class | |
| /// to become inaccessible. | |
| static void DiagnoseAccessPath(Sema &S, | |
| const EffectiveContext &EC, | |
| AccessTarget &entity) { | |
| // Save the instance context to preserve invariants. | |
| AccessTarget::SavedInstanceContext _ = entity.saveInstanceContext(); | |
| // This basically repeats the main algorithm but keeps some more | |
| // information. | |
| // The natural access so far. | |
| AccessSpecifier accessSoFar = AS_public; | |
| // Check whether we have special rights to the declaring class. | |
| if (entity.isMemberAccess()) { | |
| NamedDecl *D = entity.getTargetDecl(); | |
| accessSoFar = D->getAccess(); | |
| const CXXRecordDecl *declaringClass = entity.getDeclaringClass(); | |
| switch (HasAccess(S, EC, declaringClass, accessSoFar, entity, | |
| /*FailedTSC=*/nullptr)) { | |
| // If the declaration is accessible when named in its declaring | |
| // class, then we must be constrained by the path. | |
| case AR_accessible: | |
| accessSoFar = AS_public; | |
| entity.suppressInstanceContext(); | |
| break; | |
| case AR_inaccessible: | |
| if (accessSoFar == AS_private || | |
| declaringClass == entity.getEffectiveNamingClass()) | |
| return diagnoseBadDirectAccess(S, EC, entity); | |
| break; | |
| case AR_dependent: | |
| llvm_unreachable("cannot diagnose dependent access"); | |
| } | |
| } | |
| CXXBasePaths paths; | |
| CXXBasePath &path = *FindBestPath(S, EC, entity, accessSoFar, paths); | |
| assert(path.Access != AS_public); | |
| CXXBasePath::iterator i = path.end(), e = path.begin(); | |
| CXXBasePath::iterator constrainingBase = i; | |
| while (i != e) { | |
| --i; | |
| assert(accessSoFar != AS_none && accessSoFar != AS_private); | |
| // Is the entity accessible when named in the deriving class, as | |
| // modified by the base specifier? | |
| const CXXRecordDecl *derivingClass = i->Class->getCanonicalDecl(); | |
| const CXXBaseSpecifier *base = i->Base; | |
| // If the access to this base is worse than the access we have to | |
| // the declaration, remember it. | |
| AccessSpecifier baseAccess = base->getAccessSpecifier(); | |
| if (baseAccess > accessSoFar) { | |
| constrainingBase = i; | |
| accessSoFar = baseAccess; | |
| } | |
| switch (HasAccess(S, EC, derivingClass, accessSoFar, entity, | |
| /*FailedTSC=*/nullptr)) { | |
| case AR_inaccessible: break; | |
| case AR_accessible: | |
| accessSoFar = AS_public; | |
| entity.suppressInstanceContext(); | |
| constrainingBase = nullptr; | |
| break; | |
| case AR_dependent: | |
| llvm_unreachable("cannot diagnose dependent access"); | |
| } | |
| // If this was private inheritance, but we don't have access to | |
| // the deriving class, we're done. | |
| if (accessSoFar == AS_private) { | |
| assert(baseAccess == AS_private); | |
| assert(constrainingBase == i); | |
| break; | |
| } | |
| } | |
| // If we don't have a constraining base, the access failure must be | |
| // due to the original declaration. | |
| if (constrainingBase == path.end()) | |
| return diagnoseBadDirectAccess(S, EC, entity); | |
| // We're constrained by inheritance, but we want to say | |
| // "declared private here" if we're diagnosing a hierarchy | |
| // conversion and this is the final step. | |
| unsigned diagnostic; | |
| if (entity.isMemberAccess() || | |
| constrainingBase + 1 != path.end()) { | |
| diagnostic = diag::note_access_constrained_by_path; | |
| } else { | |
| diagnostic = diag::note_access_natural; | |
| } | |
| const CXXBaseSpecifier *base = constrainingBase->Base; | |
| S.Diag(base->getSourceRange().getBegin(), diagnostic) | |
| << base->getSourceRange() | |
| << (base->getAccessSpecifier() == AS_protected) | |
| << (base->getAccessSpecifierAsWritten() == AS_none); | |
| if (entity.isMemberAccess()) | |
| S.Diag(entity.getTargetDecl()->getLocation(), | |
| diag::note_member_declared_at); | |
| } | |
| static void DiagnoseBadAccess(Sema &S, SourceLocation Loc, | |
| const EffectiveContext &EC, | |
| AccessTarget &Entity) { | |
| const CXXRecordDecl *NamingClass = Entity.getNamingClass(); | |
| const CXXRecordDecl *DeclaringClass = Entity.getDeclaringClass(); | |
| NamedDecl *D = (Entity.isMemberAccess() ? Entity.getTargetDecl() : nullptr); | |
| S.Diag(Loc, Entity.getDiag()) | |
| << (Entity.getAccess() == AS_protected) | |
| << (D ? D->getDeclName() : DeclarationName()) | |
| << S.Context.getCanonicalTagType(NamingClass) | |
| << S.Context.getCanonicalTagType(DeclaringClass); | |
| DiagnoseAccessPath(S, EC, Entity); | |
| } | |
| /// MSVC has a bug where if during an using declaration name lookup, | |
| /// the declaration found is unaccessible (private) and that declaration | |
| /// was bring into scope via another using declaration whose target | |
| /// declaration is accessible (public) then no error is generated. | |
| /// Example: | |
| /// class A { | |
| /// public: | |
| /// int f(); | |
| /// }; | |
| /// class B : public A { | |
| /// private: | |
| /// using A::f; | |
| /// }; | |
| /// class C : public B { | |
| /// private: | |
| /// using B::f; | |
| /// }; | |
| /// | |
| /// Here, B::f is private so this should fail in Standard C++, but | |
| /// because B::f refers to A::f which is public MSVC accepts it. | |
| static bool IsMicrosoftUsingDeclarationAccessBug(Sema& S, | |
| SourceLocation AccessLoc, | |
| AccessTarget &Entity) { | |
| if (UsingShadowDecl *Shadow = | |
| dyn_cast<UsingShadowDecl>(Entity.getTargetDecl())) | |
| if (UsingDecl *UD = dyn_cast<UsingDecl>(Shadow->getIntroducer())) { | |
| const NamedDecl *OrigDecl = Entity.getTargetDecl()->getUnderlyingDecl(); | |
| if (Entity.getTargetDecl()->getAccess() == AS_private && | |
| (OrigDecl->getAccess() == AS_public || | |
| OrigDecl->getAccess() == AS_protected)) { | |
| S.Diag(AccessLoc, diag::ext_ms_using_declaration_inaccessible) | |
| << UD->getQualifiedNameAsString() | |
| << OrigDecl->getQualifiedNameAsString(); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| /// Determines whether the accessed entity is accessible. Public members | |
| /// have been weeded out by this point. | |
| static AccessResult IsAccessible(Sema &S, const EffectiveContext &EC, | |
| AccessTarget &Entity, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| // Determine the actual naming class. | |
| const CXXRecordDecl *NamingClass = Entity.getEffectiveNamingClass(); | |
| AccessSpecifier UnprivilegedAccess = Entity.getAccess(); | |
| assert(UnprivilegedAccess != AS_public && "public access not weeded out"); | |
| // Before we try to recalculate access paths, try to white-list | |
| // accesses which just trade in on the final step, i.e. accesses | |
| // which don't require [M4] or [B4]. These are by far the most | |
| // common forms of privileged access. | |
| if (UnprivilegedAccess != AS_none) { | |
| switch ( | |
| HasAccess(S, EC, NamingClass, UnprivilegedAccess, Entity, FailedTSC)) { | |
| case AR_dependent: | |
| // This is actually an interesting policy decision. We don't | |
| // *have* to delay immediately here: we can do the full access | |
| // calculation in the hope that friendship on some intermediate | |
| // class will make the declaration accessible non-dependently. | |
| // But that's not cheap, and odds are very good (note: assertion | |
| // made without data) that the friend declaration will determine | |
| // access. | |
| return AR_dependent; | |
| case AR_accessible: return AR_accessible; | |
| case AR_inaccessible: break; | |
| } | |
| } | |
| AccessTarget::SavedInstanceContext _ = Entity.saveInstanceContext(); | |
| // We lower member accesses to base accesses by pretending that the | |
| // member is a base class of its declaring class. | |
| AccessSpecifier FinalAccess; | |
| if (Entity.isMemberAccess()) { | |
| // Determine if the declaration is accessible from EC when named | |
| // in its declaring class. | |
| NamedDecl *Target = Entity.getTargetDecl(); | |
| const CXXRecordDecl *DeclaringClass = Entity.getDeclaringClass(); | |
| FinalAccess = Target->getAccess(); | |
| switch (HasAccess(S, EC, DeclaringClass, FinalAccess, Entity, FailedTSC)) { | |
| case AR_accessible: | |
| // Target is accessible at EC when named in its declaring class. | |
| // We can now hill-climb and simply check whether the declaring | |
| // class is accessible as a base of the naming class. This is | |
| // equivalent to checking the access of a notional public | |
| // member with no instance context. | |
| FinalAccess = AS_public; | |
| Entity.suppressInstanceContext(); | |
| break; | |
| case AR_inaccessible: break; | |
| case AR_dependent: return AR_dependent; // see above | |
| } | |
| if (DeclaringClass == NamingClass) | |
| return (FinalAccess == AS_public ? AR_accessible : AR_inaccessible); | |
| } else { | |
| FinalAccess = AS_public; | |
| } | |
| assert(Entity.getDeclaringClass() != NamingClass); | |
| // Append the declaration's access if applicable. | |
| CXXBasePaths Paths; | |
| CXXBasePath *Path = FindBestPath(S, EC, Entity, FinalAccess, Paths); | |
| if (!Path) | |
| return AR_dependent; | |
| assert(Path->Access <= UnprivilegedAccess && | |
| "access along best path worse than direct?"); | |
| if (Path->Access == AS_public) | |
| return AR_accessible; | |
| return AR_inaccessible; | |
| } | |
| static void DelayDependentAccess(Sema &S, | |
| const EffectiveContext &EC, | |
| SourceLocation Loc, | |
| const AccessTarget &Entity) { | |
| assert(EC.isDependent() && "delaying non-dependent access"); | |
| DeclContext *DC = EC.getInnerContext(); | |
| assert(DC->isDependentContext() && "delaying non-dependent access"); | |
| DependentDiagnostic::Create(S.Context, DC, DependentDiagnostic::Access, | |
| Loc, | |
| Entity.isMemberAccess(), | |
| Entity.getAccess(), | |
| Entity.getTargetDecl(), | |
| Entity.getNamingClass(), | |
| Entity.getBaseObjectType(), | |
| Entity.getDiag()); | |
| } | |
| static AccessResult CheckEffectiveAccess(Sema &S, const EffectiveContext &EC, | |
| SourceLocation Loc, | |
| AccessTarget &Entity, | |
| TemplateSpecCandidateSet *FailedTSC) { | |
| assert((Entity.isQuiet() || FailedTSC) && | |
| "non-quiet access check requires a candidate set"); | |
| switch (IsAccessible(S, EC, Entity, FailedTSC)) { | |
| case AR_dependent: | |
| DelayDependentAccess(S, EC, Loc, Entity); | |
| return AR_dependent; | |
| case AR_inaccessible: { | |
| if (S.getLangOpts().MSVCCompat && | |
| IsMicrosoftUsingDeclarationAccessBug(S, Loc, Entity)) | |
| return AR_accessible; | |
| if (Entity.isQuiet()) | |
| return AR_inaccessible; | |
| DiagnoseBadAccess(S, Loc, EC, Entity); | |
| FailedTSC->NoteCandidates(S, Loc); | |
| return AR_inaccessible; | |
| } | |
| case AR_accessible: | |
| return AR_accessible; | |
| } | |
| // silence unnecessary warning | |
| llvm_unreachable("invalid access result"); | |
| } | |
| static AccessResult CheckEffectiveAccess(Sema &S, const EffectiveContext &EC, | |
| SourceLocation Loc, | |
| AccessTarget &Entity) { | |
| assert(Entity.getAccess() != AS_public && "called for public access!"); | |
| if (Entity.isQuiet()) | |
| return CheckEffectiveAccess(S, EC, Loc, Entity, /*FailedTSC=*/nullptr); | |
| TemplateSpecCandidateSet FailedTSC( | |
| Loc, /*ForTakingAddress=*/false, | |
| TemplateSpecCandidateSetKind::FriendTemplate); | |
| return CheckEffectiveAccess(S, EC, Loc, Entity, &FailedTSC); | |
| } | |
| static Sema::AccessResult CheckAccess(Sema &S, SourceLocation Loc, | |
| AccessTarget &Entity) { | |
| // If the access path is public, it's accessible everywhere. | |
| if (Entity.getAccess() == AS_public) | |
| return Sema::AR_accessible; | |
| // If we're currently parsing a declaration, we may need to delay | |
| // access control checking, because our effective context might be | |
| // different based on what the declaration comes out as. | |
| // | |
| // For example, we might be parsing a declaration with a scope | |
| // specifier, like this: | |
| // A::private_type A::foo() { ... } | |
| // | |
| // friend declaration should not be delayed because it may lead to incorrect | |
| // redeclaration chain, such as: | |
| // class D { | |
| // class E{ | |
| // class F{}; | |
| // friend void foo(D::E::F& q); | |
| // }; | |
| // friend void foo(D::E::F& q); | |
| // }; | |
| if (S.DelayedDiagnostics.shouldDelayDiagnostics()) { | |
| // [class.friend]p9: | |
| // A member nominated by a friend declaration shall be accessible in the | |
| // class containing the friend declaration. The meaning of the friend | |
| // declaration is the same whether the friend declaration appears in the | |
| // private, protected, or public ([class.mem]) portion of the class | |
| // member-specification. | |
| Scope *TS = S.getCurScope(); | |
| bool IsFriendDeclaration = false; | |
| while (TS && !IsFriendDeclaration) { | |
| IsFriendDeclaration = TS->isFriendScope(); | |
| TS = TS->getParent(); | |
| } | |
| if (!IsFriendDeclaration) { | |
| S.DelayedDiagnostics.add(DelayedDiagnostic::makeAccess(Loc, Entity)); | |
| return Sema::AR_delayed; | |
| } | |
| } | |
| EffectiveContext EC(S.CurContext); | |
| switch (CheckEffectiveAccess(S, EC, Loc, Entity)) { | |
| case AR_accessible: return Sema::AR_accessible; | |
| case AR_inaccessible: return Sema::AR_inaccessible; | |
| case AR_dependent: return Sema::AR_dependent; | |
| } | |
| llvm_unreachable("invalid access result"); | |
| } | |
| void Sema::HandleDelayedAccessCheck(DelayedDiagnostic &DD, Decl *D) { | |
| // Access control for names used in the declarations of functions | |
| // and function templates should normally be evaluated in the context | |
| // of the declaration, just in case it's a friend of something. | |
| // However, this does not apply to local extern declarations. | |
| DeclContext *DC = D->getDeclContext(); | |
| if (D->isLocalExternDecl()) { | |
| DC = D->getLexicalDeclContext(); | |
| } else if (FunctionDecl *FN = dyn_cast<FunctionDecl>(D)) { | |
| DC = FN; | |
| } else if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) { | |
| if (auto *D = dyn_cast_if_present<DeclContext>(TD->getTemplatedDecl())) | |
| DC = D; | |
| } else if (auto *RD = dyn_cast<RequiresExprBodyDecl>(D)) { | |
| DC = RD; | |
| } | |
| EffectiveContext EC(DC); | |
| AccessTarget Target(DD.getAccessData()); | |
| if (CheckEffectiveAccess(*this, EC, DD.Loc, Target) == ::AR_inaccessible) | |
| DD.Triggered = true; | |
| } | |
| void Sema::HandleDependentAccessCheck(const DependentDiagnostic &DD, | |
| const MultiLevelTemplateArgumentList &TemplateArgs) { | |
| SourceLocation Loc = DD.getAccessLoc(); | |
| AccessSpecifier Access = DD.getAccess(); | |
| Decl *NamingD = FindInstantiatedDecl(Loc, DD.getAccessNamingClass(), | |
| TemplateArgs); | |
| if (!NamingD) return; | |
| Decl *TargetD = FindInstantiatedDecl(Loc, DD.getAccessTarget(), | |
| TemplateArgs); | |
| if (!TargetD) return; | |
| if (DD.isAccessToMember()) { | |
| CXXRecordDecl *NamingClass = cast<CXXRecordDecl>(NamingD); | |
| NamedDecl *TargetDecl = cast<NamedDecl>(TargetD); | |
| QualType BaseObjectType = DD.getAccessBaseObjectType(); | |
| if (!BaseObjectType.isNull()) { | |
| BaseObjectType = SubstType(BaseObjectType, TemplateArgs, Loc, | |
| DeclarationName()); | |
| if (BaseObjectType.isNull()) return; | |
| } | |
| AccessTarget Entity(Context, | |
| AccessTarget::Member, | |
| NamingClass, | |
| DeclAccessPair::make(TargetDecl, Access), | |
| BaseObjectType); | |
| Entity.setDiag(DD.getDiagnostic()); | |
| CheckAccess(*this, Loc, Entity); | |
| } else { | |
| AccessTarget Entity(Context, | |
| AccessTarget::Base, | |
| cast<CXXRecordDecl>(TargetD), | |
| cast<CXXRecordDecl>(NamingD), | |
| Access); | |
| Entity.setDiag(DD.getDiagnostic()); | |
| CheckAccess(*this, Loc, Entity); | |
| } | |
| } | |
| Sema::AccessResult Sema::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, | |
| DeclAccessPair Found) { | |
| if (!getLangOpts().AccessControl || | |
| !E->getNamingClass() || | |
| Found.getAccess() == AS_public) | |
| return AR_accessible; | |
| AccessTarget Entity(Context, AccessTarget::Member, E->getNamingClass(), | |
| Found, QualType()); | |
| Entity.setDiag(diag::err_access) << E->getSourceRange(); | |
| return CheckAccess(*this, E->getNameLoc(), Entity); | |
| } | |
| Sema::AccessResult Sema::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, | |
| DeclAccessPair Found) { | |
| if (!getLangOpts().AccessControl || | |
| Found.getAccess() == AS_public) | |
| return AR_accessible; | |
| QualType BaseType = E->getBaseType(); | |
| if (E->isArrow()) | |
| BaseType = BaseType->castAs<PointerType>()->getPointeeType(); | |
| AccessTarget Entity(Context, AccessTarget::Member, E->getNamingClass(), | |
| Found, BaseType); | |
| Entity.setDiag(diag::err_access) << E->getSourceRange(); | |
| return CheckAccess(*this, E->getMemberLoc(), Entity); | |
| } | |
| bool Sema::isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, | |
| DeclAccessPair Found, | |
| QualType ObjectType, | |
| SourceLocation Loc, | |
| const PartialDiagnostic &Diag) { | |
| // Fast path. | |
| if (Found.getAccess() == AS_public || !getLangOpts().AccessControl) | |
| return true; | |
| AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found, | |
| ObjectType); | |
| // Suppress diagnostics. | |
| Entity.setDiag(Diag); | |
| // We don't want to delay access checking even we are inside an enclosing | |
| // delayed-diagnostics scope (e.g. when parsing a later declaration whose | |
| // initializer requires explaining why a defaulted comparison operator is | |
| // deleted) | |
| llvm::scope_exit UndelayDiags( | |
| [&, CurrentState(DelayedDiagnostics.pushUndelayed())] { | |
| DelayedDiagnostics.popUndelayed(CurrentState); | |
| }); | |
| switch (CheckAccess(*this, Loc, Entity)) { | |
| case AR_accessible: return true; | |
| case AR_inaccessible: return false; | |
| case AR_dependent: llvm_unreachable("dependent for =delete computation"); | |
| case AR_delayed: llvm_unreachable("cannot delay =delete computation"); | |
| } | |
| llvm_unreachable("bad access result"); | |
| } | |
| Sema::AccessResult Sema::CheckDestructorAccess(SourceLocation Loc, | |
| CXXDestructorDecl *Dtor, | |
| const PartialDiagnostic &PDiag, | |
| QualType ObjectTy) { | |
| if (!getLangOpts().AccessControl) | |
| return AR_accessible; | |
| // There's never a path involved when checking implicit destructor access. | |
| AccessSpecifier Access = Dtor->getAccess(); | |
| if (Access == AS_public) | |
| return AR_accessible; | |
| CXXRecordDecl *NamingClass = Dtor->getParent(); | |
| if (ObjectTy.isNull()) | |
| ObjectTy = Context.getCanonicalTagType(NamingClass); | |
| AccessTarget Entity(Context, AccessTarget::Member, NamingClass, | |
| DeclAccessPair::make(Dtor, Access), | |
| ObjectTy); | |
| Entity.setDiag(PDiag); // TODO: avoid copy | |
| return CheckAccess(*this, Loc, Entity); | |
| } | |
| Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, | |
| CXXConstructorDecl *Constructor, | |
| DeclAccessPair Found, | |
| const InitializedEntity &Entity, | |
| bool IsCopyBindingRefToTemp) { | |
| if (!getLangOpts().AccessControl || Found.getAccess() == AS_public) | |
| return AR_accessible; | |
| PartialDiagnostic PD(PDiag()); | |
| switch (Entity.getKind()) { | |
| default: | |
| PD = PDiag(IsCopyBindingRefToTemp | |
| ? diag::ext_rvalue_to_reference_access_ctor | |
| : diag::err_access_ctor); | |
| break; | |
| case InitializedEntity::EK_Base: | |
| PD = PDiag(diag::err_access_base_ctor); | |
| PD << Entity.isInheritedVirtualBase() | |
| << Entity.getBaseSpecifier()->getType() | |
| << Constructor->getSpecialMemberKind(); | |
| break; | |
| case InitializedEntity::EK_Member: | |
| case InitializedEntity::EK_ParenAggInitMember: { | |
| const FieldDecl *Field = cast<FieldDecl>(Entity.getDecl()); | |
| PD = PDiag(diag::err_access_field_ctor); | |
| PD << Field->getType() << Constructor->getSpecialMemberKind(); | |
| break; | |
| } | |
| case InitializedEntity::EK_LambdaCapture: { | |
| StringRef VarName = Entity.getCapturedVarName(); | |
| PD = PDiag(diag::err_access_lambda_capture); | |
| PD << VarName << Entity.getType() << Constructor->getSpecialMemberKind(); | |
| break; | |
| } | |
| } | |
| return CheckConstructorAccess(UseLoc, Constructor, Found, Entity, PD); | |
| } | |
| Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, | |
| CXXConstructorDecl *Constructor, | |
| DeclAccessPair Found, | |
| const InitializedEntity &Entity, | |
| const PartialDiagnostic &PD) { | |
| if (!getLangOpts().AccessControl || | |
| Found.getAccess() == AS_public) | |
| return AR_accessible; | |
| CXXRecordDecl *NamingClass = Constructor->getParent(); | |
| // Initializing a base sub-object is an instance method call on an | |
| // object of the derived class. Otherwise, we have an instance method | |
| // call on an object of the constructed type. | |
| // | |
| // FIXME: If we have a parent, we're initializing the base class subobject | |
| // in aggregate initialization. It's not clear whether the object class | |
| // should be the base class or the derived class in that case. | |
| CXXRecordDecl *ObjectClass; | |
| if ((Entity.getKind() == InitializedEntity::EK_Base || | |
| Entity.getKind() == InitializedEntity::EK_Delegating) && | |
| !Entity.getParent()) { | |
| ObjectClass = cast<CXXConstructorDecl>(CurContext)->getParent(); | |
| } else if (auto *Shadow = | |
| dyn_cast<ConstructorUsingShadowDecl>(Found.getDecl())) { | |
| // If we're using an inheriting constructor to construct an object, | |
| // the object class is the derived class, not the base class. | |
| ObjectClass = Shadow->getParent(); | |
| } else { | |
| ObjectClass = NamingClass; | |
| } | |
| AccessTarget AccessEntity( | |
| Context, AccessTarget::Member, NamingClass, | |
| DeclAccessPair::make(Constructor, Found.getAccess()), | |
| Context.getCanonicalTagType(ObjectClass)); | |
| AccessEntity.setDiag(PD); | |
| return CheckAccess(*this, UseLoc, AccessEntity); | |
| } | |
| Sema::AccessResult Sema::CheckAllocationAccess(SourceLocation OpLoc, | |
| SourceRange PlacementRange, | |
| CXXRecordDecl *NamingClass, | |
| DeclAccessPair Found, | |
| bool Diagnose) { | |
| if (!getLangOpts().AccessControl || | |
| !NamingClass || | |
| Found.getAccess() == AS_public) | |
| return AR_accessible; | |
| AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found, | |
| QualType()); | |
| if (Diagnose) | |
| Entity.setDiag(diag::err_access) | |
| << PlacementRange; | |
| return CheckAccess(*this, OpLoc, Entity); | |
| } | |
| Sema::AccessResult Sema::CheckMemberAccess(SourceLocation UseLoc, | |
| CXXRecordDecl *NamingClass, | |
| DeclAccessPair Found) { | |
| if (!getLangOpts().AccessControl || | |
| !NamingClass || | |
| Found.getAccess() == AS_public) | |
| return AR_accessible; | |
| AccessTarget Entity(Context, AccessTarget::Member, NamingClass, | |
| Found, QualType()); | |
| return CheckAccess(*this, UseLoc, Entity); | |
| } | |
| Sema::AccessResult | |
| Sema::CheckStructuredBindingMemberAccess(SourceLocation UseLoc, | |
| CXXRecordDecl *DecomposedClass, | |
| DeclAccessPair Field) { | |
| if (!getLangOpts().AccessControl || | |
| Field.getAccess() == AS_public) | |
| return AR_accessible; | |
| AccessTarget Entity(Context, AccessTarget::Member, DecomposedClass, Field, | |
| Context.getCanonicalTagType(DecomposedClass)); | |
| Entity.setDiag(diag::err_decomp_decl_inaccessible_field); | |
| return CheckAccess(*this, UseLoc, Entity); | |
| } | |
| Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, | |
| Expr *ObjectExpr, | |
| const SourceRange &Range, | |
| DeclAccessPair Found) { | |
| if (!getLangOpts().AccessControl || Found.getAccess() == AS_public) | |
| return AR_accessible; | |
| auto *NamingClass = ObjectExpr->getType()->castAsCXXRecordDecl(); | |
| AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found, | |
| ObjectExpr->getType()); | |
| Entity.setDiag(diag::err_access) << ObjectExpr->getSourceRange() << Range; | |
| return CheckAccess(*this, OpLoc, Entity); | |
| } | |
| Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, | |
| Expr *ObjectExpr, | |
| Expr *ArgExpr, | |
| DeclAccessPair Found) { | |
| return CheckMemberOperatorAccess( | |
| OpLoc, ObjectExpr, ArgExpr ? ArgExpr->getSourceRange() : SourceRange(), | |
| Found); | |
| } | |
| Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, | |
| Expr *ObjectExpr, | |
| ArrayRef<Expr *> ArgExprs, | |
| DeclAccessPair FoundDecl) { | |
| SourceRange R; | |
| if (!ArgExprs.empty()) { | |
| R = SourceRange(ArgExprs.front()->getBeginLoc(), | |
| ArgExprs.back()->getEndLoc()); | |
| } | |
| return CheckMemberOperatorAccess(OpLoc, ObjectExpr, R, FoundDecl); | |
| } | |
| Sema::AccessResult Sema::CheckFriendAccess(NamedDecl *target) { | |
| assert(isa<CXXMethodDecl>(target->getAsFunction())); | |
| // Friendship lookup is a redeclaration lookup, so there's never an | |
| // inheritance path modifying access. | |
| AccessSpecifier access = target->getAccess(); | |
| if (!getLangOpts().AccessControl || access == AS_public) | |
| return AR_accessible; | |
| CXXMethodDecl *method = cast<CXXMethodDecl>(target->getAsFunction()); | |
| AccessTarget entity(Context, AccessTarget::Member, | |
| cast<CXXRecordDecl>(target->getDeclContext()), | |
| DeclAccessPair::make(target, access), | |
| /*no instance context*/ QualType()); | |
| entity.setDiag(diag::err_access_friend_function) | |
| << (method->getQualifier() ? method->getQualifierLoc().getSourceRange() | |
| : method->getNameInfo().getSourceRange()); | |
| // We need to bypass delayed-diagnostics because we might be called | |
| // while the ParsingDeclarator is active. | |
| EffectiveContext EC(CurContext); | |
| switch (CheckEffectiveAccess(*this, EC, target->getLocation(), entity)) { | |
| case ::AR_accessible: return Sema::AR_accessible; | |
| case ::AR_inaccessible: return Sema::AR_inaccessible; | |
| case ::AR_dependent: return Sema::AR_dependent; | |
| } | |
| llvm_unreachable("invalid access result"); | |
| } | |
| Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr, | |
| DeclAccessPair Found) { | |
| if (!getLangOpts().AccessControl || | |
| Found.getAccess() == AS_none || | |
| Found.getAccess() == AS_public) | |
| return AR_accessible; | |
| OverloadExpr *Ovl = OverloadExpr::find(OvlExpr).Expression; | |
| CXXRecordDecl *NamingClass = Ovl->getNamingClass(); | |
| AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found, | |
| /*no instance context*/ QualType()); | |
| Entity.setDiag(diag::err_access) | |
| << Ovl->getSourceRange(); | |
| return CheckAccess(*this, Ovl->getNameLoc(), Entity); | |
| } | |
| Sema::AccessResult Sema::CheckBaseClassAccess( | |
| SourceLocation AccessLoc, CXXRecordDecl *Base, CXXRecordDecl *Derived, | |
| const CXXBasePath &Path, unsigned DiagID, | |
| llvm::function_ref<void(PartialDiagnostic &)> SetupPDiag, bool ForceCheck, | |
| bool ForceUnprivileged) { | |
| if (!ForceCheck && !getLangOpts().AccessControl) | |
| return AR_accessible; | |
| if (Path.Access == AS_public) | |
| return AR_accessible; | |
| AccessTarget Entity(Context, AccessTarget::Base, Base, Derived, Path.Access); | |
| if (DiagID) | |
| SetupPDiag(Entity.setDiag(DiagID)); | |
| if (ForceUnprivileged) { | |
| switch ( | |
| CheckEffectiveAccess(*this, EffectiveContext(), AccessLoc, Entity)) { | |
| case ::AR_accessible: | |
| return Sema::AR_accessible; | |
| case ::AR_inaccessible: | |
| return Sema::AR_inaccessible; | |
| case ::AR_dependent: | |
| return Sema::AR_dependent; | |
| } | |
| llvm_unreachable("unexpected result from CheckEffectiveAccess"); | |
| } | |
| return CheckAccess(*this, AccessLoc, Entity); | |
| } | |
| Sema::AccessResult Sema::CheckBaseClassAccess(SourceLocation AccessLoc, | |
| QualType Base, QualType Derived, | |
| const CXXBasePath &Path, | |
| unsigned DiagID, bool ForceCheck, | |
| bool ForceUnprivileged) { | |
| return CheckBaseClassAccess( | |
| AccessLoc, Base->getAsCXXRecordDecl(), Derived->getAsCXXRecordDecl(), | |
| Path, DiagID, [&](PartialDiagnostic &PD) { PD << Derived << Base; }, | |
| ForceCheck, ForceUnprivileged); | |
| } | |
| void Sema::CheckLookupAccess(const LookupResult &R) { | |
| assert(getLangOpts().AccessControl | |
| && "performing access check without access control"); | |
| assert(R.getNamingClass() && "performing access check without naming class"); | |
| for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { | |
| if (I.getAccess() != AS_public) { | |
| AccessTarget Entity(Context, AccessedEntity::Member, | |
| R.getNamingClass(), I.getPair(), | |
| R.getBaseObjectType()); | |
| Entity.setDiag(diag::err_access); | |
| CheckAccess(*this, R.getNameLoc(), Entity); | |
| } | |
| } | |
| } | |
| bool Sema::IsSimplyAccessible(NamedDecl *Target, CXXRecordDecl *NamingClass, | |
| QualType BaseType) { | |
| // Perform the C++ accessibility checks first. | |
| if (Target->isCXXClassMember() && NamingClass) { | |
| if (!getLangOpts().CPlusPlus) | |
| return false; | |
| // The unprivileged access is AS_none as we don't know how the member was | |
| // accessed, which is described by the access in DeclAccessPair. | |
| // `IsAccessible` will examine the actual access of Target (i.e. | |
| // Decl->getAccess()) when calculating the access. | |
| AccessTarget Entity(Context, AccessedEntity::Member, NamingClass, | |
| DeclAccessPair::make(Target, AS_none), BaseType); | |
| EffectiveContext EC(CurContext); | |
| return ::IsAccessible(*this, EC, Entity, /*FailedTSC=*/nullptr) != | |
| ::AR_inaccessible; | |
| } | |
| if (ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(Target)) { | |
| // @public and @package ivars are always accessible. | |
| if (Ivar->getCanonicalAccessControl() == ObjCIvarDecl::Public || | |
| Ivar->getCanonicalAccessControl() == ObjCIvarDecl::Package) | |
| return true; | |
| // If we are inside a class or category implementation, determine the | |
| // interface we're in. | |
| ObjCInterfaceDecl *ClassOfMethodDecl = nullptr; | |
| if (ObjCMethodDecl *MD = getCurMethodDecl()) | |
| ClassOfMethodDecl = MD->getClassInterface(); | |
| else if (FunctionDecl *FD = getCurFunctionDecl()) { | |
| if (ObjCImplDecl *Impl | |
| = dyn_cast<ObjCImplDecl>(FD->getLexicalDeclContext())) { | |
| if (ObjCImplementationDecl *IMPD | |
| = dyn_cast<ObjCImplementationDecl>(Impl)) | |
| ClassOfMethodDecl = IMPD->getClassInterface(); | |
| else if (ObjCCategoryImplDecl* CatImplClass | |
| = dyn_cast<ObjCCategoryImplDecl>(Impl)) | |
| ClassOfMethodDecl = CatImplClass->getClassInterface(); | |
| } | |
| } | |
| // If we're not in an interface, this ivar is inaccessible. | |
| if (!ClassOfMethodDecl) | |
| return false; | |
| // If we're inside the same interface that owns the ivar, we're fine. | |
| if (declaresSameEntity(ClassOfMethodDecl, Ivar->getContainingInterface())) | |
| return true; | |
| // If the ivar is private, it's inaccessible. | |
| if (Ivar->getCanonicalAccessControl() == ObjCIvarDecl::Private) | |
| return false; | |
| return Ivar->getContainingInterface()->isSuperClassOf(ClassOfMethodDecl); | |
| } | |
| return true; | |
| } |