From 12538618fb4317e5bcbf540f8cbccb8629a6dc17 Mon Sep 17 00:00:00 2001 From: Michael Gottesman Date: Sat, 19 Oct 2024 13:04:19 -0700 Subject: [PATCH] [gardening] Move ActorIsolation method definitions from Decl.cpp -> ActorIsolation.cpp. Just noticed this while working in the general area. --- lib/AST/ActorIsolation.cpp | 176 ++++++++++++++++++++++++++++++++++++ lib/AST/Decl.cpp | 177 ------------------------------------- 2 files changed, 176 insertions(+), 177 deletions(-) diff --git a/lib/AST/ActorIsolation.cpp b/lib/AST/ActorIsolation.cpp index ad73caf6f60f4..e09b8002c6852 100644 --- a/lib/AST/ActorIsolation.cpp +++ b/lib/AST/ActorIsolation.cpp @@ -12,6 +12,9 @@ #include "swift/AST/ActorIsolation.h" #include "swift/AST/ASTContext.h" +#include "swift/AST/ConformanceLookup.h" +#include "swift/AST/Decl.h" +#include "swift/AST/Expr.h" using namespace swift; @@ -19,3 +22,176 @@ ActorIsolation ActorIsolation::forMainActor(ASTContext &ctx) { return ActorIsolation::forGlobalActor( ctx.getMainActorType()->mapTypeOutOfContext()); } + +ActorIsolation::ActorIsolation(Kind kind, NominalTypeDecl *actor, + unsigned parameterIndex) + : actorInstance(actor), kind(kind), isolatedByPreconcurrency(false), + silParsed(false), parameterIndex(parameterIndex) {} + +ActorIsolation::ActorIsolation(Kind kind, VarDecl *actor, + unsigned parameterIndex) + : actorInstance(actor), kind(kind), isolatedByPreconcurrency(false), + silParsed(false), parameterIndex(parameterIndex) {} + +ActorIsolation::ActorIsolation(Kind kind, Expr *actor, unsigned parameterIndex) + : actorInstance(actor), kind(kind), isolatedByPreconcurrency(false), + silParsed(false), parameterIndex(parameterIndex) {} + +ActorIsolation::ActorIsolation(Kind kind, Type globalActor) + : globalActor(globalActor), kind(kind), isolatedByPreconcurrency(false), + silParsed(false), parameterIndex(0) {} + +ActorIsolation +ActorIsolation::forActorInstanceParameter(Expr *actor, + unsigned parameterIndex) { + auto &ctx = actor->getType()->getASTContext(); + + // An isolated value of `nil` is statically nonisolated. + // FIXME: Also allow 'Optional.none' + if (isa(actor)) + return ActorIsolation::forNonisolated(/*unsafe*/ false); + + // An isolated value of `.shared` is statically + // global actor isolated. + if (auto *memberRef = dyn_cast(actor)) { + // Check that the member declaration witnesses the `shared` + // requirement of the `GlobalActor` protocol. + auto declRef = memberRef->getDecl(); + auto baseType = memberRef->getBase()->getType()->getMetatypeInstanceType(); + if (auto globalActor = ctx.getProtocol(KnownProtocolKind::GlobalActor)) { + auto conformance = checkConformance(baseType, globalActor); + if (conformance && + conformance.getWitnessByName(baseType, ctx.Id_shared) == declRef) { + return ActorIsolation::forGlobalActor(baseType); + } + } + } + + return ActorIsolation(ActorInstance, actor, parameterIndex + 1); +} + +ActorIsolation ActorIsolation::forActorInstanceSelf(ValueDecl *decl) { + if (auto *fn = dyn_cast(decl)) + return ActorIsolation(ActorInstance, fn->getImplicitSelfDecl(), 0); + + if (auto *storage = dyn_cast(decl)) { + if (auto *fn = storage->getAccessor(AccessorKind::Get)) { + return ActorIsolation(ActorInstance, fn->getImplicitSelfDecl(), 0); + } + } + + auto *dc = decl->getDeclContext(); + return ActorIsolation(ActorInstance, dc->getSelfNominalTypeDecl(), 0); +} + +ActorIsolation ActorIsolation::forActorInstanceSelf(NominalTypeDecl *selfDecl) { + return ActorIsolation(ActorInstance, selfDecl, 0); +} + +NominalTypeDecl *ActorIsolation::getActor() const { + assert(getKind() == ActorInstance || getKind() == GlobalActor); + + if (silParsed) + return nullptr; + + if (getKind() == GlobalActor) { + return getGlobalActor()->getAnyNominal(); + } + + Type actorType; + + if (auto *instance = actorInstance.dyn_cast()) { + actorType = instance->getTypeInContext(); + } else if (auto *expr = actorInstance.dyn_cast()) { + actorType = expr->getType(); + } + + if (actorType) { + if (auto wrapped = actorType->getOptionalObjectType()) { + actorType = wrapped; + } + return actorType->getReferenceStorageReferent()->getAnyActor(); + } + + return actorInstance.get(); +} + +VarDecl *ActorIsolation::getActorInstance() const { + assert(getKind() == ActorInstance); + + if (silParsed) + return nullptr; + + return actorInstance.dyn_cast(); +} + +Expr *ActorIsolation::getActorInstanceExpr() const { + assert(getKind() == ActorInstance); + + if (silParsed) + return nullptr; + + return actorInstance.dyn_cast(); +} + +bool ActorIsolation::isMainActor() const { + if (silParsed) + return false; + + if (isGlobalActor()) { + if (auto *nominal = getGlobalActor()->getAnyNominal()) + return nominal->isMainActor(); + } + + return false; +} + +bool ActorIsolation::isDistributedActor() const { + if (silParsed) + return false; + + if (getKind() != ActorInstance) + return false; + + return getActor()->isDistributedActor(); +} + +bool ActorIsolation::isEqual(const ActorIsolation &lhs, + const ActorIsolation &rhs) { + if (lhs.getKind() != rhs.getKind()) + return false; + + switch (lhs.getKind()) { + case Nonisolated: + case NonisolatedUnsafe: + case Unspecified: + return true; + + case Erased: + // Different functions with erased isolation have the same *kind* of + // isolation, but we must generally assume that they're not isolated + // the *same way*, which is what this function is apparently supposed + // to answer. + return false; + + case ActorInstance: { + auto *lhsActor = lhs.getActorInstance(); + auto *rhsActor = rhs.getActorInstance(); + if (lhsActor && rhsActor) { + // FIXME: This won't work for arbitrary isolated parameter captures. + if ((lhsActor->isSelfParameter() && rhsActor->isSelfParamCapture()) || + (lhsActor->isSelfParamCapture() && rhsActor->isSelfParameter())) { + return true; + } + } + + // The parameter index doesn't matter; only the actor instance + // values must be equal. + return (lhs.getActor() == rhs.getActor() && + lhs.actorInstance == rhs.actorInstance); + } + + case GlobalActor: + return areTypesEqual(lhs.globalActor, rhs.globalActor); + } +} diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp index 64b04965f01ef..4c6cbf788d087 100644 --- a/lib/AST/Decl.cpp +++ b/lib/AST/Decl.cpp @@ -11476,183 +11476,6 @@ void swift::simple_display(llvm::raw_ostream &out, AnyFunctionRef fn) { out << "closure"; } -ActorIsolation::ActorIsolation(Kind kind, NominalTypeDecl *actor, - unsigned parameterIndex) - : actorInstance(actor), kind(kind), isolatedByPreconcurrency(false), - silParsed(false), parameterIndex(parameterIndex) {} - -ActorIsolation::ActorIsolation(Kind kind, VarDecl *actor, - unsigned parameterIndex) - : actorInstance(actor), kind(kind), isolatedByPreconcurrency(false), - silParsed(false), parameterIndex(parameterIndex) {} - -ActorIsolation::ActorIsolation(Kind kind, Expr *actor, - unsigned parameterIndex) - : actorInstance(actor), kind(kind), isolatedByPreconcurrency(false), - silParsed(false), parameterIndex(parameterIndex) {} - -ActorIsolation::ActorIsolation(Kind kind, Type globalActor) - : globalActor(globalActor), kind(kind), isolatedByPreconcurrency(false), - silParsed(false), parameterIndex(0) {} - -ActorIsolation -ActorIsolation::forActorInstanceParameter(Expr *actor, - unsigned parameterIndex) { - auto &ctx = actor->getType()->getASTContext(); - - // An isolated value of `nil` is statically nonisolated. - // FIXME: Also allow 'Optional.none' - if (dyn_cast(actor)) - return ActorIsolation::forNonisolated(/*unsafe*/false); - - // An isolated value of `.shared` is statically - // global actor isolated. - if (auto *memberRef = dyn_cast(actor)) { - // Check that the member declaration witnesses the `shared` - // requirement of the `GlobalActor` protocol. - auto declRef = memberRef->getDecl(); - auto baseType = - memberRef->getBase()->getType()->getMetatypeInstanceType(); - if (auto globalActor = ctx.getProtocol(KnownProtocolKind::GlobalActor)) { - auto conformance = checkConformance(baseType, globalActor); - if (conformance && - conformance.getWitnessByName(baseType, ctx.Id_shared) == declRef) { - return ActorIsolation::forGlobalActor(baseType); - } - } - } - - return ActorIsolation(ActorInstance, actor, parameterIndex + 1); -} - -ActorIsolation -ActorIsolation::forActorInstanceSelf(ValueDecl *decl) { - if (auto *fn = dyn_cast(decl)) - return ActorIsolation(ActorInstance, fn->getImplicitSelfDecl(), 0); - - if (auto *storage = dyn_cast(decl)) { - if (auto *fn = storage->getAccessor(AccessorKind::Get)) { - return ActorIsolation(ActorInstance, fn->getImplicitSelfDecl(), 0); - } - } - - auto *dc = decl->getDeclContext(); - return ActorIsolation(ActorInstance, dc->getSelfNominalTypeDecl(), 0); -} - -ActorIsolation ActorIsolation::forActorInstanceSelf(NominalTypeDecl *selfDecl) { - return ActorIsolation(ActorInstance, selfDecl, 0); -} - -NominalTypeDecl *ActorIsolation::getActor() const { - assert(getKind() == ActorInstance || getKind() == GlobalActor); - - if (silParsed) - return nullptr; - - if (getKind() == GlobalActor) { - return getGlobalActor()->getAnyNominal(); - } - - Type actorType; - - if (auto *instance = actorInstance.dyn_cast()) { - actorType = instance->getTypeInContext(); - } else if (auto *expr = actorInstance.dyn_cast()) { - actorType = expr->getType(); - } - - if (actorType) { - if (auto wrapped = actorType->getOptionalObjectType()) { - actorType = wrapped; - } - return actorType - ->getReferenceStorageReferent()->getAnyActor(); - } - - return actorInstance.get(); -} - -VarDecl *ActorIsolation::getActorInstance() const { - assert(getKind() == ActorInstance); - - if (silParsed) - return nullptr; - - return actorInstance.dyn_cast(); -} - -Expr *ActorIsolation::getActorInstanceExpr() const { - assert(getKind() == ActorInstance); - - if (silParsed) - return nullptr; - - return actorInstance.dyn_cast(); -} - -bool ActorIsolation::isMainActor() const { - if (silParsed) - return false; - - if (isGlobalActor()) { - if (auto *nominal = getGlobalActor()->getAnyNominal()) - return nominal->isMainActor(); - } - - return false; -} - -bool ActorIsolation::isDistributedActor() const { - if (silParsed) - return false; - - if (getKind() != ActorInstance) - return false; - - return getActor()->isDistributedActor(); -} - -bool ActorIsolation::isEqual(const ActorIsolation &lhs, - const ActorIsolation &rhs) { - if (lhs.getKind() != rhs.getKind()) - return false; - - switch (lhs.getKind()) { - case Nonisolated: - case NonisolatedUnsafe: - case Unspecified: - return true; - - case Erased: - // Different functions with erased isolation have the same *kind* of - // isolation, but we must generally assume that they're not isolated - // the *same way*, which is what this function is apparently supposed - // to answer. - return false; - - case ActorInstance: { - auto *lhsActor = lhs.getActorInstance(); - auto *rhsActor = rhs.getActorInstance(); - if (lhsActor && rhsActor) { - // FIXME: This won't work for arbitrary isolated parameter captures. - if ((lhsActor->isSelfParameter() && rhsActor->isSelfParamCapture()) || - (lhsActor->isSelfParamCapture() && rhsActor->isSelfParameter())) { - return true; - } - } - - // The parameter index doesn't matter; only the actor instance - // values must be equal. - return (lhs.getActor() == rhs.getActor() && - lhs.actorInstance == rhs.actorInstance); - } - - case GlobalActor: - return areTypesEqual(lhs.globalActor, rhs.globalActor); - } -} - BuiltinTupleDecl::BuiltinTupleDecl(Identifier Name, DeclContext *Parent) : NominalTypeDecl(DeclKind::BuiltinTuple, Parent, Name, SourceLoc(), ArrayRef(), nullptr) {}