Model isolated parameters in ActorIsolation.

A function can be actor instance-isolated to one of its parameters.
Make sure that this is reflected in ActorIsolation, so such a function
doesn't get a different actor isolation.

Author: DougGregor

include/swift/AST/ActorIsolation.h

@@ -74,14 +74,17 @@ class ActorIsolation {
     Type globalActor;
     void *pointer;
   };
-  uint8_t kind : 3;
-  uint8_t isolatedByPreconcurrency : 1;
+  unsigned kind : 3;
+  unsigned isolatedByPreconcurrency : 1;
+  unsigned parameterIndex : 28;
 
-  ActorIsolation(Kind kind, NominalTypeDecl *actor)
-      : actor(actor), kind(kind), isolatedByPreconcurrency(false) { }
+  ActorIsolation(Kind kind, NominalTypeDecl *actor, unsigned parameterIndex)
+      : actor(actor), kind(kind), isolatedByPreconcurrency(false),
+        parameterIndex(parameterIndex) { }
 
   ActorIsolation(Kind kind, Type globalActor)
-      : globalActor(globalActor), kind(kind), isolatedByPreconcurrency(false) { }
+      : globalActor(globalActor), kind(kind), isolatedByPreconcurrency(false),
+        parameterIndex(0) { }
 
 public:
   static ActorIsolation forUnspecified() {
@@ -92,8 +95,13 @@ class ActorIsolation {
     return ActorIsolation(Independent, nullptr);
   }
 
-  static ActorIsolation forActorInstance(NominalTypeDecl *actor) {
-    return ActorIsolation(ActorInstance, actor);
+  static ActorIsolation forActorInstanceSelf(NominalTypeDecl *actor) {
+    return ActorIsolation(ActorInstance, actor, 0);
+  }
+
+  static ActorIsolation forActorInstanceParameter(NominalTypeDecl *actor,
+                                                  unsigned parameterIndex) {
+    return ActorIsolation(ActorInstance, actor, parameterIndex + 1);
   }
 
   static ActorIsolation forGlobalActor(Type globalActor, bool unsafe) {
@@ -109,6 +117,14 @@ class ActorIsolation {
 
   bool isIndependent() const { return kind == Independent; }
 
+  /// Retrieve the parameter to which actor-instance isolation applies.
+  ///
+  /// Parameter 0 is `self`.
+  unsigned getActorInstanceParameter() const {
+    assert(getKind() == ActorInstance);
+    return parameterIndex;
+  }
+
   bool isActorIsolated() const {
     switch (getKind()) {
     case ActorInstance:
@@ -169,7 +185,7 @@ class ActorIsolation {
       return true;
 
     case ActorInstance:
-      return lhs.actor == rhs.actor;
+      return lhs.actor == rhs.actor && lhs.parameterIndex == rhs.parameterIndex;
 
     case GlobalActor:
     case GlobalActorUnsafe:
@@ -183,7 +199,9 @@ class ActorIsolation {
   }
 
   friend llvm::hash_code hash_value(const ActorIsolation &state) {
-    return llvm::hash_combine(state.kind, state.pointer);
+    return llvm::hash_combine(
+        state.kind, state.pointer, state.isolatedByPreconcurrency,
+        state.parameterIndex);
   }
 };
 

lib/AST/Decl.cpp

@@ -9232,7 +9232,8 @@ ActorIsolation swift::getActorIsolationOfContext(DeclContext *dc) {
       auto actor = selfDecl->getType()->getReferenceStorageReferent()
           ->getAnyActor();
       assert(actor && "Bad closure actor isolation?");
-      return ActorIsolation::forActorInstance(actor)
+      // FIXME: This could be a parameter... or a capture... hmmm.
+      return ActorIsolation::forActorInstanceSelf(actor)
         .withPreconcurrency(isolation.preconcurrency());
     }
     }

lib/SILGen/SILGenPoly.cpp

@@ -4438,6 +4438,7 @@ void SILGenFunction::emitProtocolWitness(
 
     // For an instance actor, get the actor 'self'.
     if (*enterIsolation == ActorIsolation::ActorInstance) {
+      assert(enterIsolation->getActorInstanceParameter() == 0 && "Not self?");
       auto actorSelfVal = origParams.back();
 
       if (actorSelfVal.getType().isAddress()) {

lib/SILGen/SILGenProlog.cpp

@@ -670,16 +670,6 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
     switch (actorIsolation.getKind()) {
     case ActorIsolation::Unspecified:
     case ActorIsolation::Independent:
-      // If this is an async function that has an isolated parameter, hop
-      // to it.
-      if (F.isAsync()) {
-        for (auto param : *funcDecl->getParameters()) {
-          if (param->isIsolated()) {
-            loadExpectedExecutorForLocalVar(param);
-            break;
-          }
-        }
-      }
       break;
 
     case ActorIsolation::ActorInstance: {
@@ -693,10 +683,19 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
                 .getIsolatedParamCapture()) {
           loadExpectedExecutorForLocalVar(isolatedParam);
         } else {
-          assert(selfParam && "no self parameter for ActorInstance isolation");
           auto loc = RegularLocation::getAutoGeneratedLocation(F.getLocation());
-          ManagedValue selfArg = ManagedValue::forUnmanaged(F.getSelfArgument());
-          ExpectedExecutor = emitLoadActorExecutor(loc, selfArg);
+          ManagedValue actorArg;
+          if (actorIsolation.getActorInstanceParameter() == 0) {
+            assert(selfParam && "no self parameter for ActorInstance isolation");
+            auto selfArg = ManagedValue::forUnmanaged(F.getSelfArgument());
+            ExpectedExecutor = emitLoadActorExecutor(loc, selfArg);
+          } else {
+            unsigned isolatedParamIdx =
+                actorIsolation.getActorInstanceParameter() - 1;
+            auto param = funcDecl->getParameters()->get(isolatedParamIdx);
+            assert(param->isIsolated());
+            loadExpectedExecutorForLocalVar(param);
+          }
         }
       }
       break;

lib/Sema/TypeCheckConcurrency.cpp

@@ -136,7 +136,7 @@ bool swift::usesFlowSensitiveIsolation(AbstractFunctionDecl const *fn) {
       return true;
 
     // construct an isolation corresponding to the type.
-    auto actorTypeIso = ActorIsolation::forActorInstance(nominal);
+    auto actorTypeIso = ActorIsolation::forActorInstanceSelf(nominal);
 
     return requiresFlowIsolation(actorTypeIso, cast<ConstructorDecl>(fn));
   }
@@ -2521,7 +2521,6 @@ namespace {
         return false;
 
       // Check for isolated parameters.
-      Optional<unsigned> isolatedParamIdx;
       for (unsigned paramIdx : range(fnType->getNumParams())) {
         // We only care about isolated parameters.
         if (!fnType->getParams()[paramIdx].isIsolated())
@@ -2545,8 +2544,8 @@ namespace {
               KnownProtocolKind::Actor);
         }
 
-        unsatisfiedIsolation = ActorIsolation::forActorInstance(nominal);
-        isolatedParamIdx = paramIdx;
+        unsatisfiedIsolation =
+            ActorIsolation::forActorInstanceParameter(nominal, paramIdx);
         break;
       }
 
@@ -2595,7 +2594,8 @@ namespace {
 
         case ActorIsolation::ActorInstance:
           apply->setImplicitlyAsync(
-            ImplicitActorHopTarget::forIsolatedParameter(*isolatedParamIdx));
+            ImplicitActorHopTarget::forIsolatedParameter(
+                unsatisfiedIsolation->getActorInstanceParameter() - 1));
           break;
 
         case ActorIsolation::Unspecified:
@@ -2847,8 +2847,12 @@ namespace {
       if (partialApply && result.isolation.isGlobalActor())
         return false;
 
-      // A call to a global-actor-isolated function is diagnosed elsewhere.
-      if (!partialApply && result.isolation.isGlobalActor() &&
+      // A call to a global-actor-isolated function, or a function with an
+      // isolated parameter, is diagnosed elsewhere.
+      if (!partialApply &&
+          (result.isolation.isGlobalActor() ||
+           (result.isolation == ActorIsolation::ActorInstance &&
+            result.isolation.getActorInstanceParameter() > 0)) &&
           isa<AbstractFunctionDecl>(decl))
         return false;
 
@@ -3654,14 +3658,45 @@ static OverrideIsolationResult validOverrideIsolation(
   }
 }
 
+/// Retrieve the index of the first isolated parameter of the given
+/// declaration, if there is one.
+static Optional<unsigned> getIsolatedParamIndex(ValueDecl *value) {
+  auto params = getParameterList(value);
+  if (!params)
+    return None;
+
+  for (unsigned paramIdx : range(params->size())) {
+    auto param = params->get(paramIdx);
+    if (param->isIsolated())
+      return paramIdx;
+  }
+
+  return None;
+}
+
 ActorIsolation ActorIsolationRequest::evaluate(
     Evaluator &evaluator, ValueDecl *value) const {
   // If this declaration has actor-isolated "self", it's isolated to that
   // actor.
   if (evaluateOrDefault(evaluator, HasIsolatedSelfRequest{value}, false)) {
     auto actor = value->getDeclContext()->getSelfNominalTypeDecl();
     assert(actor && "could not find the actor that 'self' is isolated to");
-    return ActorIsolation::forActorInstance(actor);
+    return ActorIsolation::forActorInstanceSelf(actor);
+  }
+
+  // If this declaration has an isolated parameter, it's isolated to that
+  // parameter.
+  if (auto paramIdx = getIsolatedParamIndex(value)) {
+    // FIXME: This doesn't allow us to find an Actor or DistributedActor
+    // bound on the parameter type effectively.
+    auto param = getParameterList(value)->get(*paramIdx);
+    Type paramType = param->getInterfaceType();
+    if (paramType->isTypeParameter()) {
+      paramType = param->getDeclContext()->mapTypeIntoContext(paramType);
+    }
+
+    if (auto actor = paramType->getAnyActor())
+      return ActorIsolation::forActorInstanceParameter(actor, *paramIdx);
   }
 
   auto isolationFromAttr = getIsolationFromAttributes(value);
@@ -3947,6 +3982,10 @@ bool HasIsolatedSelfRequest::evaluate(
     value = accessor->getStorage();
   }
 
+  // If there is an isolated parameter, then "self" is not isolated.
+  if (getIsolatedParamIndex(value))
+    return false;
+
   // Check whether this member can be isolated to an actor at all.
   auto memberIsolation = getMemberIsolationPropagation(value);
   if (!memberIsolation)
@@ -4950,7 +4989,7 @@ static ActorIsolation getActorIsolationForReference(
     // as needing to enter the actor.
     if (auto nominal = ctor->getDeclContext()->getSelfNominalTypeDecl()) {
       if (nominal->isAnyActor())
-        return ActorIsolation::forActorInstance(nominal);
+        return ActorIsolation::forActorInstanceSelf(nominal);
     }
 
     // Fall through to treat initializers like any other declaration.
@@ -4966,7 +5005,7 @@ static ActorIsolation getActorIsolationForReference(
         declIsolation.isIndependent()) {
       if (auto nominal = var->getDeclContext()->getSelfNominalTypeDecl()) {
         if (nominal->isAnyActor())
-          return ActorIsolation::forActorInstance(nominal);
+          return ActorIsolation::forActorInstanceSelf(nominal);
 
         auto nominalIsolation = getActorIsolation(nominal);
         if (nominalIsolation.isGlobalActor())
@@ -5137,7 +5176,8 @@ ActorReferenceResult ActorReferenceResult::forReference(
 
   // The declaration we are accessing is actor-isolated. First, check whether
   // we are on the same actor already.
-  if (actorInstance && declIsolation == ActorIsolation::ActorInstance) {
+  if (actorInstance && declIsolation == ActorIsolation::ActorInstance &&
+      declIsolation.getActorInstanceParameter() == 0) {
     // If this instance is isolated, we're in the same concurrency domain.
     if (actorInstance->isIsolated())
       return forSameConcurrencyDomain(declIsolation);

test/Concurrency/isolated_parameters.swift

@@ -41,7 +41,7 @@ func testIsolatedParamCalls(a: isolated A, b: A) {
   globalFunc(b)
 
   globalFuncIsolated(a)
-  globalFuncIsolated(b) // expected-error{{call to actor-isolated global function 'globalFuncIsolated' in a synchronous nonisolated context}}
+  globalFuncIsolated(b) // expected-error{{call to actor-isolated global function 'globalFuncIsolated' in a synchronous actor-isolated context}}
 }
 
 @available(SwiftStdlib 5.1, *)
@@ -63,6 +63,7 @@ typealias MyFn = (isolated: Int) -> Void // expected-error {{function types cann
 typealias MyFnFixed = (_: isolated MyActor) -> Void
 
 func standalone(_: isolated MyActor) {}
+
 func check() {
   let _: MyFnFixed = standalone
   let _: MyFnFixed = { (_: isolated MyActor) in () }
@@ -148,6 +149,14 @@ func testExistentialIsolated(a: isolated P2, b: P2) async {
 // "isolated" parameters of closures make the closure itself isolated.
 extension TestActor {
   func isolatedMethod() { }
+  // expected-note@-1{{calls to instance method 'isolatedMethod()' from outside of its actor context are implicitly asynchronous}}
+
+  func isolatedToParameter(_ other: isolated TestActor) {
+    isolatedMethod()
+    // expected-error@-1{{actor-isolated instance method 'isolatedMethod()' can not be referenced on a non-isolated actor instance}}
+
+    other.isolatedMethod()
+  }
 }
 
 @available(SwiftStdlib 5.1, *)