fix SILGen of access to isolated wrapper around instance actor property

The fix is to implement part of SILGen that I asserted could not
happen because I couldn't formulate a situation where an access
to instance-isolated state would happen at the point in the code.

But, if a property wrapper's wrapped-value is global-actor
isolated, and is wrapping an actor instance, then it does happen.

Implementation details:

If the address is isolated to an actor instance, then we need the
base in order to perform a hop prior to starting the access,
so I just pass the base value through SILGen to the point it is
needed, since the base is available from all of the callers.

Author: kavon

lib/SILGen/SILGenLValue.cpp

@@ -564,7 +564,8 @@ namespace {
 } // end anonymous namespace
 
 static SILValue enterAccessScope(SILGenFunction &SGF, SILLocation loc,
-                                 SILValue addr, LValueTypeData typeData,
+                                 ManagedValue base, SILValue addr,
+                                 LValueTypeData typeData,
                                  SGFAccessKind accessKind,
                                  SILAccessEnforcement enforcement,
                                  Optional<ActorIsolation> actorIso) {
@@ -574,10 +575,8 @@ static SILValue enterAccessScope(SILGenFunction &SGF, SILLocation loc,
   assert(SGF.isInFormalEvaluationScope() &&
          "tried to enter access scope without a writeback scope!");
 
-  // Only expecting global-actor isolation here, since there's no base / self.
-  assert(!actorIso || actorIso->isGlobalActor());
   ExecutorBreadcrumb prevExecutor =
-      SGF.emitHopToTargetActor(loc, actorIso, /*maybeSelf=*/None);
+      SGF.emitHopToTargetActor(loc, actorIso, base);
 
   // Enter the access.
   addr = SGF.B.createBeginAccess(loc, addr, silAccessKind, enforcement,
@@ -596,13 +595,14 @@ static SILValue enterAccessScope(SILGenFunction &SGF, SILLocation loc,
 }
 
 static ManagedValue enterAccessScope(SILGenFunction &SGF, SILLocation loc,
-                                     ManagedValue addr, LValueTypeData typeData,
+                                     ManagedValue base, ManagedValue addr,
+                                     LValueTypeData typeData,
                                      SGFAccessKind accessKind,
                                      SILAccessEnforcement enforcement,
                                      Optional<ActorIsolation> actorIso) {
   return ManagedValue::forLValue(
-           enterAccessScope(SGF, loc, addr.getLValueAddress(), typeData,
-                            accessKind, enforcement, actorIso));
+      enterAccessScope(SGF, loc, base, addr.getLValueAddress(), typeData,
+                       accessKind, enforcement, actorIso));
 }
 
 // Find the base of the formal access at `address`. If the base requires an
@@ -758,7 +758,7 @@ namespace {
       // declarations. Access marker verification is aware of these cases.
       if (!IsNonAccessing && !Field->isLet()) {
         if (auto enforcement = SGF.getDynamicEnforcement(Field)) {
-          result = enterAccessScope(SGF, loc, result, getTypeData(),
+          result = enterAccessScope(SGF, loc, base, result, getTypeData(),
                                     getAccessKind(), *enforcement,
                                     takeActorIsolation());
         }
@@ -1034,9 +1034,9 @@ namespace {
         return Value;
 
       SILValue addr = Value.getLValueAddress();
-      addr = enterAccessScope(SGF, loc, addr, getTypeData(),
-                              getAccessKind(), *Enforcement,
-                              takeActorIsolation());
+      addr =
+          enterAccessScope(SGF, loc, base, addr, getTypeData(), getAccessKind(),
+                           *Enforcement, takeActorIsolation());
 
       return ManagedValue::forLValue(addr);
     }
@@ -1798,9 +1798,9 @@ namespace {
       }
 
       // Enter an unsafe access scope for the access.
-      addr = enterAccessScope(SGF, loc, addr, getTypeData(), getAccessKind(),
-                              SILAccessEnforcement::Unsafe,
-                              ActorIso);
+      addr =
+          enterAccessScope(SGF, loc, base, addr, getTypeData(), getAccessKind(),
+                           SILAccessEnforcement::Unsafe, ActorIso);
 
       return addr;
     }

test/SILGen/hop_to_executor_async_prop.swift

@@ -603,4 +603,44 @@ struct Container {
     static func getRefOrCrash() async -> CatBox {
         return await this!.isoRef
     }
+}
+
+
+@propertyWrapper
+struct StateObject<ObjectType> {
+    @MainActor(unsafe)
+    var wrappedValue: ObjectType {
+        fatalError()
+    }
+    init(wrappedValue: ObjectType) {}
+}
+
+final private actor Coordinactor {
+    var someValue: Int?
+}
+
+struct Blah {
+    @StateObject private var coordinator = Coordinactor()
+
+    // closure #1 in Blah.test()
+    // CHECK-LABEL: sil private [ossa] @$s4test4BlahVAAyyFyyYaYbcfU_ : $@convention(thin) @Sendable @async (Blah) -> () {
+    // CHECK:       hop_to_executor {{%[0-9]+}} : $MainActor
+    // CHECK:       [[ACTOR_OBJ_RAW:%[0-9]+]] = apply {{%[0-9]+}}({{%[0-9]+}}) : $@convention(method) (Blah) -> @owned Coordinactor
+    // CHECK:       hop_to_executor {{%[0-9]+}} : $Optional<Builtin.Executor>
+    // CHECK:       [[ACTOR_OBJ:%[0-9]+]] = begin_borrow [[ACTOR_OBJ_RAW]] : $Coordinactor
+    // CHECK:       [[VAL:%[0-9]+]] = ref_element_addr [[ACTOR_OBJ]] : $Coordinactor, #Coordinactor.someValue
+    // CHECK:       hop_to_executor [[ACTOR_OBJ]]
+    // CHECK:       [[VAL_ACCESS:%[0-9]+]] = begin_access [read] [dynamic] [[VAL]] : $*Optional<Int>
+    // CHECK:       {{%[0-9]+}} = load [trivial] %17 : $*Optional<Int>
+    // CHECK:       end_access %17 : $*Optional<Int>
+    // CHECK:       hop_to_executor {{%[0-9]+}} : $Optional<Builtin.Executor>
+    // CHECK: } // end sil function '$s4test4BlahVAAyyFyyYaYbcfU_'
+    @available(SwiftStdlib 5.5, *)
+    func test() {
+        Task.detached {
+            if await coordinator.someValue == nil {
+                fatalError()
+            }
+        }
+    }
 }