AccessRequests.cpp

//===--- AccessRequests.cpp - AccessLevel and AccessScope Requests --------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

#include"swift/Subsystems.h"
#include"swift/AST/AccessRequests.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/Decl.h"
#include"swift/AST/DiagnosticsCommon.h"
#include"swift/AST/Module.h"
#include"swift/AST/NameLookupRequests.h"
#include"swift/AST/SourceFile.h"
#include"swift/AST/Types.h"
#include"swift/Basic/Assertions.h"

#include"llvm/ADT/bit.h"

#include<limits>

usingnamespaceswift;

namespaceswift {
// Implement the access-control type zone.
#defineSWIFT_TYPEID_ZONE AccessControl
#defineSWIFT_TYPEID_HEADER"swift/AST/AccessTypeIDZone.def"
#include"swift/Basic/ImplementTypeIDZone.h"
#undef SWIFT_TYPEID_ZONE
#undef SWIFT_TYPEID_HEADER
}

//----------------------------------------------------------------------------//
// AccessLevel computation
//----------------------------------------------------------------------------//
AccessLevel
AccessLevelRequest::evaluate(Evaluator &evaluator, ValueDecl *D) const {
assert(!D->hasAccess());

// ABI decls share the access level of their API decl.
auto abiRole = ABIRoleInfo(D);
if (!abiRole.providesAPI() && abiRole.getCounterpart())
return abiRole.getCounterpart()->getFormalAccess();

// Check if the decl has an explicit access control attribute.
if (auto *AA = D->getAttrs().getAttribute<AccessControlAttr>())
return AA->getAccess();

// Special case for accessors, which inherit the access of their storage.
// decl. A setter attribute can also override this.
if (auto accessor = dyn_cast<AccessorDecl>(D)) {
 AbstractStorageDecl *storage = accessor->getStorage();
switch (accessor->getAccessorKind()) {
case AccessorKind::Get:
case AccessorKind::DistributedGet:
case AccessorKind::Address:
case AccessorKind::Read:
case AccessorKind::Read2:
return storage->getFormalAccess();
case AccessorKind::Set:
case AccessorKind::MutableAddress:
case AccessorKind::Modify:
case AccessorKind::Modify2:
return storage->getSetterFormalAccess();
case AccessorKind::WillSet:
case AccessorKind::DidSet:
// These are only needed to synthesize the setter.
return AccessLevel::Private;
case AccessorKind::Init:
// These are only called from within the same module.
return AccessLevel::Internal;
 }
 }

// Special case for opaque type decls, which inherit the access of their
// naming decls.
if (auto *opaqueType = dyn_cast<OpaqueTypeDecl>(D)) {
if (auto *namingDecl = opaqueType->getNamingDecl())
return namingDecl->getFormalAccess();
 }

 DeclContext *DC = D->getDeclContext();

// Special case for generic parameters; we just give them a dummy
// access level.
if (isa<GenericTypeParamDecl>(D)) {
return AccessLevel::Internal;
 }

// Special case for associated types: inherit access from protocol.
if (auto assocType = dyn_cast<AssociatedTypeDecl>(D)) {
auto prot = assocType->getProtocol();
returnstd::max(prot->getFormalAccess(), AccessLevel::Internal);
 }

// Special case for dtors and enum elements: inherit from container
if (D->getKind() == DeclKind::Destructor ||
 D->getKind() == DeclKind::EnumElement) {
if (D->hasInterfaceType() && D->isInvalid()) {
return AccessLevel::Private;
 } else {
auto container = dyn_cast<NominalTypeDecl>(DC);
if (D->getKind() == DeclKind::Destructor && !container) {
// A destructor in an extension means @_objcImplementation. An
// @_objcImplementation class's deinit is only called by the ObjC thunk,
// if at all, so it is nonpublic.
return AccessLevel::Internal;
 }

returnstd::max(container->getFormalAccess(), AccessLevel::Internal);
 }
 }

switch (DC->getContextKind()) {
case DeclContextKind::TopLevelCodeDecl:
case DeclContextKind::SerializedTopLevelCodeDecl:
// Variables declared in a top-level 'guard' statement can be accessed in
// later top-level code.
return AccessLevel::FilePrivate;
case DeclContextKind::AbstractClosureExpr:
case DeclContextKind::SerializedAbstractClosure:
if (isa<ParamDecl>(D)) {
// Closure parameters may need to be accessible to the enclosing
// context, for single-expression closures.
return AccessLevel::FilePrivate;
 } else {
return AccessLevel::Private;
 }
case DeclContextKind::Initializer:
case DeclContextKind::AbstractFunctionDecl:
case DeclContextKind::SubscriptDecl:
case DeclContextKind::EnumElementDecl:
return AccessLevel::Private;
case DeclContextKind::Package:
return AccessLevel::Package;
case DeclContextKind::Module:
case DeclContextKind::FileUnit:
return AccessLevel::Internal;
case DeclContextKind::GenericTypeDecl: {
auto generic = cast<GenericTypeDecl>(DC);
 AccessLevel access = AccessLevel::Internal;
if (isa<ProtocolDecl>(generic))
access = std::max(AccessLevel::FilePrivate, generic->getFormalAccess());
returnaccess;
 }
case DeclContextKind::ExtensionDecl:
return cast<ExtensionDecl>(DC)->getDefaultAccessLevel();
case DeclContextKind::MacroDecl:
// There are no declarations inside a macro.
return AccessLevel::Private;
 }
llvm_unreachable("unhandled kind");
}

std::optional<AccessLevel> AccessLevelRequest::getCachedResult() const {
auto valueDecl = std::get<0>(getStorage());
if (valueDecl->hasAccess())
return valueDecl->TypeAndAccess.getInt().getValue();

return std::nullopt;
}

voidAccessLevelRequest::cacheResult(AccessLevel value) const {
auto valueDecl = std::get<0>(getStorage());
 valueDecl->setAccess(value);
}

//----------------------------------------------------------------------------//
// SetterAccessLevel computation
//----------------------------------------------------------------------------//
//
// An AbstractStorageDecl has both its own formal access and also a special
// "setter" formal access like "private(set)" that might override (and lower)
// the normal one, when evaluating the accessibility of mutating accessors.
//
// As this value can be computed, stored, synthesized and set independently from
// the cycle of computation associated with formal accesses, we give it its own
// request.

// In a .swiftinterface file, a stored property with an explicit @_hasStorage
// attribute but no setter is assumed to have originally been a private(set).
staticboolisStoredWithPrivateSetter(VarDecl *VD) {
auto *HSA = VD->getAttrs().getAttribute<HasStorageAttr>();
if (!HSA || HSA->isImplicit())
returnfalse;

auto *DC = VD->getDeclContext();
auto *SF = DC->getParentSourceFile();
if (!SF || SF->Kind != SourceFileKind::Interface)
returnfalse;

if (VD->isLet() ||
 VD->getParsedAccessor(AccessorKind::Set))
returnfalse;

returntrue;
}

AccessLevel
SetterAccessLevelRequest::evaluate(Evaluator &evaluator,
 AbstractStorageDecl *ASD) const {
assert(!ASD->Accessors.getInt().hasValue());

// ABI decls share the access level of their API decl.
auto abiRole = ABIRoleInfo(ASD);
if (!abiRole.providesAPI() && abiRole.getCounterpart())
return abiRole.getCounterpart()->getSetterFormalAccess();

if (auto *SAA = ASD->getAttrs().getAttribute<SetterAccessAttr>())
return SAA->getAccess();

if (auto *VD = dyn_cast<VarDecl>(ASD))
if (isStoredWithPrivateSetter(VD))
return AccessLevel::Private;

return ASD->getFormalAccess();
}

std::optional<AccessLevel> SetterAccessLevelRequest::getCachedResult() const {
auto abstractStorageDecl = std::get<0>(getStorage());
if (abstractStorageDecl->Accessors.getInt().hasValue())
return abstractStorageDecl->Accessors.getInt().getValue();

return std::nullopt;
}

voidSetterAccessLevelRequest::cacheResult(AccessLevel value) const {
auto abstractStorageDecl = std::get<0>(getStorage());
// NB: don't call setSetterAccess here because it drives values through to the
// associated accessors' formalAccess, which we might also be in the middle of
// doing a request for. Reserve setSetterAccess for deserialization &
// clangImporter use.
assert(!abstractStorageDecl->Accessors.getInt().hasValue());
 abstractStorageDecl->Accessors.setInt(value);
}


//----------------------------------------------------------------------------//
// DefaultAccessLevel computation
//----------------------------------------------------------------------------//

std::pair<AccessLevel, AccessLevel>
DefaultAndMaxAccessLevelRequest::evaluate(Evaluator &evaluator,
 ExtensionDecl *ED) const {
auto &Ctx = ED->getASTContext();
assert(!ED->hasDefaultAccessLevel());

 AccessLevel maxAccess = AccessLevel::Public;

if (ED->getGenericParams()) {
// Only check the trailing 'where' requirements. Other requirements come
// from the extended type and have already been checked.
 DirectlyReferencedTypeDecls typeDecls =
evaluateOrDefault(Ctx.evaluator, TypeDeclsFromWhereClauseRequest{ED}, {});

 std::optional<AccessScope> maxScope = AccessScope::getPublic();

// Try to scope the extension's access to the least public type mentioned
// in its where clause.
for (auto *typeDecl : typeDecls.first) {
if (isa<TypeAliasDecl>(typeDecl) || isa<NominalTypeDecl>(typeDecl)) {
auto scope = typeDecl->getFormalAccessScope(ED->getDeclContext());
 maxScope = maxScope->intersectWith(scope);
 }
 }

// Now include the scope of the extended nominal type.
if (NominalTypeDecl *nominal = ED->getExtendedNominal()) {
auto scope = nominal->getFormalAccessScope(ED->getDeclContext());
 maxScope = maxScope->intersectWith(scope);
 }

if (!maxScope.has_value()) {
// This is an error case and will be diagnosed elsewhere.
 maxAccess = AccessLevel::Public;
 } elseif (maxScope->isPublic()) {
 maxAccess = AccessLevel::Public;
 } elseif (maxScope->isPackage()) {
 maxAccess = AccessLevel::Package;
 } elseif (isa<ModuleDecl>(maxScope->getDeclContext())) {
 maxAccess = AccessLevel::Internal;
 } else {
// Because extensions are always at top-level, they should never
// reference declarations not at the top level. (And any such references
// should be diagnosed elsewhere.) This code should not crash if that
// occurs, though.
 maxAccess = AccessLevel::FilePrivate;
 }
 }

 AccessLevel defaultAccess;
if (auto *AA = ED->getAttrs().getAttribute<AccessControlAttr>())
 defaultAccess = std::max(AA->getAccess(), AccessLevel::FilePrivate);
else
 defaultAccess = AccessLevel::Internal;

// Don't set the max or default access level to 'open'. This should
// be diagnosed as invalid anyway.
 defaultAccess = std::min(defaultAccess, AccessLevel::Public);
 maxAccess = std::min(maxAccess, AccessLevel::Public);

// Normally putting a public member in an internal extension is harmless,
// because that member can never be used elsewhere. But if some of the types
// in the signature are public, it could actually end up getting picked in
// overload resolution. Therefore, we only enforce the maximum access if the
// extension has a 'where' clause.
if (ED->getTrailingWhereClause())
 defaultAccess = std::min(defaultAccess, maxAccess);
else
 maxAccess = AccessLevel::Public;

returnstd::make_pair(defaultAccess, maxAccess);
}

// Default and Max access levels are stored combined as a 3-bit bitset. The Bits
// are numbered using the 3 middle values of the AccessLevel enumeration, and
// the combined value is just the bitwise-OR of the bits for Default and Max.
//
// For example, if Max=Internal and Default=FilePrivate, we will see:
//
// 0 1 1
// | | |
// | | [FilePrivate]
// | |
// | [Internal]
// |
// [Public]
//
// This is unambiguous to decode because of the following facts:
//
// - At least one of the bits is set (all-zero means "not yet set").
// - At most two of the bits are set.
// - Max >= Default by definition.
//
// So we decode Max as the last (high) bit that is set, and Default as the first
// (low). And add one to each, to map them back into AccessLevels.

std::optional<std::pair<AccessLevel, AccessLevel>>
DefaultAndMaxAccessLevelRequest::getCachedResult() const {
auto extensionDecl = std::get<0>(getStorage());
if (extensionDecl->hasDefaultAccessLevel()) {
uint8_t Bits = extensionDecl->getDefaultAndMaxAccessLevelBits();
assert(Bits != 0x7 && "more than two bits set for Default and Max");

uint8_t lastSet = Bits == 0 ? std::numeric_limits<uint8_t>::max()
 : (llvm::countl_zero(Bits) ^
 (std::numeric_limits<uint8_t>::digits - 1));
uint8_t firstSet = Bits == 0 ? std::numeric_limits<uint8_t>::max()
 : llvm::countr_zero(Bits);
 AccessLevel Max = static_cast<AccessLevel>(lastSet + 1);
 AccessLevel Default = static_cast<AccessLevel>(firstSet + 1);

assert(Max >= Default);
returnstd::make_pair(Default, Max);
 }
return std::nullopt;
}

void
DefaultAndMaxAccessLevelRequest::cacheResult(
 std::pair<AccessLevel, AccessLevel> value) const {
auto extensionDecl = std::get<0>(getStorage());
 extensionDecl->setDefaultAndMaxAccessLevelBits(value.first, value.second);
assert(getCachedResult().value().first == value.first);
assert(getCachedResult().value().second == value.second);
}

// Define request evaluation functions for each of the access requests.
static AbstractRequestFunction *accessRequestFunctions[] = {
#defineSWIFT_REQUEST(Zone, Name, Sig, Caching, LocOptions) \
reinterpret_cast<AbstractRequestFunction *>(&Name::evaluateRequest),
#include"swift/AST/AccessTypeIDZone.def"
#undef SWIFT_REQUEST
};

voidswift::registerAccessRequestFunctions(Evaluator &evaluator) {
 evaluator.registerRequestFunctions(Zone::AccessControl,
 accessRequestFunctions);
}