Merge pull request swiftlang#77600 from rjmccall/simplify-constructor-concurrency-prolog-emission

Use common code paths for constructor concurrency prologs

Author: rjmccall

lib/SILGen/SILGenConcurrency.cpp

@@ -226,37 +226,32 @@ void SILGenFunction::emitExpectedExecutorProlog() {
   }
 }
 
-void SILGenFunction::emitConstructorPrologActorHop(
-    SILLocation loc, std::optional<ActorIsolation> maybeIso) {
-  loc = loc.asAutoGenerated();
-
-  SILValue executorForInitialHop;
-
-  if (maybeIso) {
-    // If the constructor is isolated to `self`, this must be an actor
-    // constructor.  Lazily emit the ExpectedExecutor reference so that
-    // DI can lower it appropriately.
-    if (maybeIso->getKind() == ActorIsolation::ActorInstance &&
-        maybeIso->getActorInstance() ==
-               cast<ConstructorDecl>(F.getDeclRef().getDecl())
-                 ->getImplicitSelfDecl()) {
+void SILGenFunction::emitConstructorExpectedExecutorProlog() {
+  auto ctor = cast<ConstructorDecl>(F.getDeclRef().getDecl());
+
+  // In async actor initializers that are isolated to self, we need
+  // to emit the ExpectedExecutor reference lazily.
+  if (ctor->hasAsync()) {
+    auto isolation = getActorIsolation(ctor);
+    auto selfDecl = ctor->getImplicitSelfDecl();
+
+    if (isolation.getKind() == ActorIsolation::ActorInstance &&
+        isolation.getActorInstance() == selfDecl) {
       assert(isCtorWithHopsInjectedByDefiniteInit());
       ExpectedExecutor.setLazy();
-      executorForInitialHop = emitGenericExecutor(loc);
 
-    // Otherwise, emit the executor normally.
-    } else if (auto executor = emitExecutor(loc, *maybeIso, std::nullopt)) {
-      executorForInitialHop = *executor;
-      ExpectedExecutor.set(executorForInitialHop);
-    }
-  }
+      auto loc = SILLocation(selfDecl);
+      loc.markAsPrologue();
+      loc = loc.asAutoGenerated();
 
-  if (!ExpectedExecutor.isValid()) {
-    executorForInitialHop = emitGenericExecutor(loc);
-    ExpectedExecutor.set(executorForInitialHop);
+      auto initialExecutor = emitGenericExecutor(loc);
+      B.createHopToExecutor(loc, initialExecutor, /*mandatory*/ false);
+      return;
+    }
   }
 
-  B.createHopToExecutor(loc, executorForInitialHop, /*mandatory*/ false);
+  // Otherwise, emit the normal expected executor prolog.
+  emitExpectedExecutorProlog();
 }
 
 void SILGenFunction::emitPrologGlobalActorHop(SILLocation loc,

lib/SILGen/SILGenConstructor.cpp

@@ -673,12 +673,7 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
   AllocatorMetatype = emitConstructorMetatypeArg(*this, ctor);
 
   // Make sure we've hopped to the right global actor, if any.
-  if (ctor->hasAsync()) {
-    auto isolation = getActorIsolation(ctor);
-    SILLocation prologueLoc(selfDecl);
-    prologueLoc.markAsPrologue();
-    emitConstructorPrologActorHop(prologueLoc, isolation);
-  }
+  emitConstructorExpectedExecutorProlog();
 
   // Create a basic block to jump to for the implicit 'self' return.
   // We won't emit this until after we've emitted the body.
@@ -1134,12 +1129,7 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     selfClassDecl->isDistributedActor() && !isDelegating;
 
   // Make sure we've hopped to the right global actor, if any.
-  if (ctor->hasAsync()) {
-    auto isolation = getActorIsolation(ctor);
-    SILLocation prologueLoc(selfDecl);
-    prologueLoc.markAsPrologue();
-    emitConstructorPrologActorHop(prologueLoc, isolation);
-  }
+  emitConstructorExpectedExecutorProlog();
 
   if (!NeedsBoxForSelf) {
     SILLocation PrologueLoc(selfDecl);

lib/SILGen/SILGenFunction.h

@@ -1201,17 +1201,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// that unsafely inherits its executor.
   bool unsafelyInheritsExecutor();
 
-  /// A version of `emitHopToTargetActor` that is specialized to the needs
-  /// of various types of ConstructorDecls, like class or value initializers,
-  /// because their prolog emission is not the same as for regular functions.
-  ///
-  /// This function emits the appropriate hop_to_executor for a constructor's
-  /// prologue.
-  ///
-  /// NOTE: this does not support actor initializers!
-  void emitConstructorPrologActorHop(SILLocation loc,
-                                     std::optional<ActorIsolation> actorIso);
-
   /// Set the given global actor as the isolation for this function
   /// (generally a thunk) and hop to it.
   void emitPrologGlobalActorHop(SILLocation loc, Type globalActor);
@@ -1322,6 +1311,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// Set up the ExpectedExecutor field for the current function and emit
   /// whatever hops or assertions are locally expected.
   void emitExpectedExecutorProlog();
+  void emitConstructorExpectedExecutorProlog();
 
   /// Create SILArguments in the entry block that bind a single value
   /// of the given parameter suitably for being forwarded.

test/Concurrency/isolated_parameters.swift

@@ -585,3 +585,8 @@ public actor MyActorIsolatedParameterMerge {
     }
   }
 }
+
+// rdar://138394497
+class ClassWithIsolatedAsyncInitializer {
+    init(isolation: isolated (any Actor)? = #isolation) async {}
+}