(rdar://87412308) fix missing actor hop for global-actor isolated inits of an actor type.

For global-actor isolated async inits within an actor, we will have separate restrictions
on access to self's differently-isolated stored properties to prevent data races. But,
we also must be on the global actor while in such initializers. The problem was only
that the prologue was missing a hop because of a bad conditional check. Previously
the check assumed that actors cannot have global-actor isolated initializers, but they
can currently.

Author: kavon

lib/SILGen/SILGenConstructor.cpp

@@ -315,6 +315,34 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
   return;
 }
 
+/// Returns true if the given async constructor will have its
+/// required actor hops injected later by definite initialization.
+static bool ctorHopsInjectedByDefiniteInit(ConstructorDecl *ctor,
+                                           ActorIsolation const& isolation) {
+  // must be async, but we can assume that.
+  assert(ctor->hasAsync());
+
+  auto *dc = ctor->getDeclContext();
+  auto selfClassDecl = dc->getSelfClassDecl();
+
+  // must be an actor
+  if (!selfClassDecl || !selfClassDecl->isAnyActor())
+    return false;
+
+  // must be instance isolated
+  switch (isolation) {
+    case ActorIsolation::ActorInstance:
+    case ActorIsolation::DistributedActorInstance:
+      return true;
+
+    case ActorIsolation::Unspecified:
+    case ActorIsolation::Independent:
+    case ActorIsolation::GlobalActor:
+    case ActorIsolation::GlobalActorUnsafe:
+      return false;
+  }
+}
+
 void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(ctor);
 
@@ -360,9 +388,13 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
 
   // Make sure we've hopped to the right global actor, if any.
   if (ctor->hasAsync()) {
-    SILLocation prologueLoc(selfDecl);
-    prologueLoc.markAsPrologue();
-    emitConstructorPrologActorHop(prologueLoc, getActorIsolation(ctor));
+    auto isolation = getActorIsolation(ctor);
+    // if it's not injected by definite init, we do it in the prologue now.
+    if (!ctorHopsInjectedByDefiniteInit(ctor, isolation)) {
+      SILLocation prologueLoc(selfDecl);
+      prologueLoc.markAsPrologue();
+      emitConstructorPrologActorHop(prologueLoc, isolation);
+    }
   }
 
   // Create a basic block to jump to for the implicit 'self' return.
@@ -754,10 +786,14 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     selfClassDecl->isDistributedActor() && !isDelegating;
 
   // Make sure we've hopped to the right global actor, if any.
-  if (ctor->hasAsync() && !selfClassDecl->isActor()) {
-    SILLocation prologueLoc(selfDecl);
-    prologueLoc.markAsPrologue();
-    emitConstructorPrologActorHop(prologueLoc, getActorIsolation(ctor));
+  if (ctor->hasAsync()) {
+    auto isolation = getActorIsolation(ctor);
+    // if it's not injected by definite init, we do it in the prologue now.
+    if (!ctorHopsInjectedByDefiniteInit(ctor, isolation)) {
+      SILLocation prologueLoc(selfDecl);
+      prologueLoc.markAsPrologue();
+      emitConstructorPrologActorHop(prologueLoc, isolation);
+    }
   }
 
   if (!NeedsBoxForSelf) {

test/SILGen/hop_to_executor.swift

@@ -1,6 +1,7 @@
 // RUN: %target-swift-frontend -emit-silgen %s -module-name test -swift-version 5  -disable-availability-checking | %FileCheck --enable-var-scope %s --implicit-check-not 'hop_to_executor {{%[0-9]+}}'
 // REQUIRES: concurrency
 
+func unspecifiedAsync() async {}
 
 actor MyActor {
 
@@ -75,6 +76,45 @@ actor MyActor {
   init() {
     p = 27
   }
+
+  // CHECK-LABEL: sil hidden [ossa] @$s4test7MyActorC4withACSi_tYacfc : $@convention(method) @async (Int, @owned MyActor) -> @owned MyActor {
+  // CHECK:         bb0({{%[0-9]+}} : $Int, {{%[0-9]+}} : @owned $MyActor):
+  // CHECK:           hop_to_executor {{%[0-9]+}} : $MainActor
+  // CHECK:           builtin "initializeDefaultActor"
+  // CHECK:           [[FUNC:%[0-9]+]] = function_ref @$s4test16unspecifiedAsyncyyYaF : $@convention(thin) @async () -> ()
+  // CHECK:           %24 = apply [[FUNC]]() : $@convention(thin) @async () -> ()
+  // CHECK-NEXT:      hop_to_executor {{%[0-9]+}} : $MainActor
+  // CHECK:       } // end sil function '$s4test7MyActorC4withACSi_tYacfc'
+  @MainActor
+  init(with v: Int) async {
+    p = 1
+    await unspecifiedAsync()
+    p = 2
+  }
+
+  // CHECK-LABEL: sil hidden [ossa] @$s4test7MyActorC10delegatingACSb_tYacfC : $@convention(method) @async (Bool, @thick MyActor.Type) -> @owned MyActor {
+  //        ** first hop is in the prologue
+  // CHECK:         bb0({{%[0-9]+}} : $Bool, {{%[0-9]+}} : $@thick MyActor.Type):
+  // CHECK:           hop_to_executor {{%[0-9]+}} : $MainActor
+  // CHECK:           struct_extract {{%[0-9]+}} : $Bool, #Bool._value
+  // CHECK:           cond_br
+  //        ** second hop is right after delegating to the async init
+  // CHECK:         = apply {{%[0-9]+}}({{%[0-9]+}}, {{%[0-9]+}}) : $@convention(method) @async (Int, @thick MyActor.Type) -> @owned MyActor
+  // CHECK-NEXT:    hop_to_executor {{%[0-9]+}} : $MainActor
+  //        ** third hop is right after calling an arbitrary async function
+  // CHECK:         [[FUNC:%[0-9]+]] = function_ref @$s4test16unspecifiedAsyncyyYaF : $@convention(thin) @async () -> ()
+  // CHECK:         = apply [[FUNC]]() : $@convention(thin) @async () -> ()
+  // CHECK-NEXT:    hop_to_executor %9 : $MainActor
+  // CHECK:       } // end sil function '$s4test7MyActorC10delegatingACSb_tYacfC'
+  @MainActor
+  convenience init(delegating c: Bool) async {
+    if c {
+      self.init()
+    } else {
+      await self.init(with: 0)
+    }
+    await unspecifiedAsync()
+  }
 }
 
 @globalActor