Merge pull request #39708 from kavon/actor-init-fixes

Author: swift-ci

include/swift/AST/ActorIsolation.h

@@ -106,6 +106,8 @@ class ActorIsolation {
   operator Kind() const { return getKind(); }
 
   bool isUnspecified() const { return kind == Unspecified; }
+  
+  bool isIndependent() const { return kind == Independent; }
 
   NominalTypeDecl *getActor() const {
     assert(getKind() == ActorInstance || getKind() == DistributedActorInstance);

include/swift/AST/DiagnosticsSIL.def

@@ -168,14 +168,12 @@ ERROR(variable_defer_use_uninit,none,
 ERROR(self_closure_use_uninit,none,
       "'self' captured by a closure before all members were initialized", ())
 
-/// false == sync; true == global-actor isolated
-ERROR(self_use_actor_init,none,
-      "this use of actor 'self' %select{can only|cannot}0 appear in "
-      "%select{an async|a global-actor isolated}0 initializer",
-      (bool))
-ERROR(self_disallowed_actor_init,none,
-      "actor 'self' %select{can only|cannot}0 %1 from "
-      "%select{an async|a global-actor isolated}0 initializer",
+ERROR(self_disallowed_nonisolated_actor_init,none,
+      "%select{|this use of }0actor 'self' cannot %2 %select{from|in}0 "
+      "%select{a non-isolated, designated|a global-actor isolated}1 initializer",
+      (bool, bool, StringRef))
+ERROR(self_disallowed_plain_actor_init,none,
+      "%select{|this use of }0actor 'self' can only %1 %select{from|in}0 an async initializer",
       (bool, StringRef))
 NOTE(actor_convenience_init,none,
      "convenience initializers allow non-isolated use of 'self' once "

include/swift/AST/DiagnosticsSema.def

@@ -4611,6 +4611,12 @@ ERROR(nonisolated_mutable_storage,none,
 ERROR(nonisolated_local_var,none,
       "'nonisolated' can not be applied to local variables",
       ())
+ERROR(nonisolated_actor_sync_init,none,
+      "'nonisolated' on an actor's synchronous initializer is invalid",
+      ())
+ERROR(nonisolated_actor_convenience_init,none,
+      "'nonisolated' on an actor's convenience initializer is redundant",
+      ())
 
 ERROR(actor_instance_property_wrapper,none,
       "%0 property in property wrapper type %1 cannot be isolated to "

lib/AST/ASTContext.cpp

@@ -2936,7 +2936,6 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
   bool isStatic = false;
   SelfAccessKind selfAccess = SelfAccessKind::NonMutating;
   bool isDynamicSelf = false;
-  bool isIsolated = false;
 
   if (auto *FD = dyn_cast<FuncDecl>(AFD)) {
     isStatic = FD->isStatic();
@@ -2954,10 +2953,6 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
     else if (wantDynamicSelf && FD->hasDynamicSelfResult())
       isDynamicSelf = true;
 
-    // If this is a non-static method within an actor, the 'self' parameter
-    // is isolated if this declaration is isolated.
-    isIsolated = evaluateOrDefault(
-        Ctx.evaluator, HasIsolatedSelfRequest{AFD}, false);
   } else if (auto *CD = dyn_cast<ConstructorDecl>(AFD)) {
     if (isInitializingCtor) {
       // initializing constructors of value types always have an implicitly
@@ -3014,6 +3009,10 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
   if (isStatic)
     return AnyFunctionType::Param(MetatypeType::get(selfTy, Ctx));
 
+  // `self` is isolated if typechecker says the function is isolated to it.
+  bool isIsolated =
+      evaluateOrDefault(Ctx.evaluator, HasIsolatedSelfRequest{AFD}, false);
+
   auto flags = ParameterTypeFlags().withIsolated(isIsolated);
   switch (selfAccess) {
   case SelfAccessKind::Consuming:

lib/SILGen/SILGenConstructor.cpp

@@ -681,6 +681,8 @@ void SILGenFunction::emitConstructorPrologActorHop(
   }
 }
 
+// MARK: class constructor
+
 void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(ctor);
 
@@ -784,9 +786,8 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
   }
 
   // Distributed actor initializers implicitly initialize their transport and id
-  if (isDesignatedDistActorInit) {
+  if (isDesignatedDistActorInit)
     emitDistActorImplicitPropertyInits(ctor, selfArg);
-  }
 
   // Prepare the end of initializer location.
   SILLocation endOfInitLoc = RegularLocation(ctor);
@@ -818,12 +819,6 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     failureExitBB = createBasicBlock();
     failureExitArg = failureExitBB->createPhiArgument(
         resultLowering.getLoweredType(), OwnershipKind::Owned);
-    
-    // For an async distributed actor init, we must `resignIdentity` before
-    // the clean-ups are triggered in this failure block.
-    if (isDesignatedDistActorInit && ctor->hasAsync()) {
-      emitResignIdentityCall(loc, selfClassDecl, selfArg);
-    }
 
     Cleanups.emitCleanupsForReturn(ctor, IsForUnwind);
     SILValue nilResult =
@@ -878,9 +873,6 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
 
   // For distributed actors, their synchronous initializers invoke "actor ready"
   // at the very end, just before returning on a successful initialization.
-  // There is no need for injecting `resignIdentity` calls in such inits,
-  // even if they are failable or throwing, because we will never call
-  // `actorReady` at a point before the init can exit abnormally.
   if (isDesignatedDistActorInit && !ctor->hasAsync()) {
     RegularLocation loc(ctor);
     loc.markAutoGenerated();

lib/SILGen/SILGenDistributed.cpp

@@ -178,6 +178,35 @@ static void emitIdentityInit(SILGenFunction &SGF, ConstructorDecl *ctor,
   initializeProperty(SGF, loc, borrowedSelfArg.getValue(), var, temp);
 }
 
+namespace {
+/// Cleanup to resign the identity of a distributed actor if an abnormal exit happens.
+class ResignIdentity : public Cleanup {
+  ClassDecl *actorDecl;
+  SILValue self;
+public:
+  ResignIdentity(ClassDecl *actorDecl, SILValue self)
+    : actorDecl(actorDecl), self(self) {
+      assert(actorDecl->isDistributedActor());
+    }
+
+  void emit(SILGenFunction &SGF, CleanupLocation l, ForUnwind_t forUnwind) override {
+    if (forUnwind == IsForUnwind) {
+      l.markAutoGenerated();
+      SGF.emitResignIdentityCall(l, actorDecl,
+                                 ManagedValue::forUnmanaged(self));
+    }
+  }
+
+  void dump(SILGenFunction &SGF) const override {
+#ifndef NDEBUG
+    llvm::errs() << "ResignIdentity "
+                 << "State:" << getState() << " "
+                 << "Self: " << self << "\n";
+#endif
+  }
+};
+} // end anonymous namespace
+
 void SILGenFunction::emitDistActorImplicitPropertyInits(
     ConstructorDecl *ctor, ManagedValue selfArg) {
   // Only designated initializers should perform this initialization.
@@ -189,6 +218,10 @@ void SILGenFunction::emitDistActorImplicitPropertyInits(
   selfArg = selfArg.borrow(*this, loc);
   emitTransportInit(*this, ctor, loc, selfArg);
   emitIdentityInit(*this, ctor, loc, selfArg);
+
+  // register a clean-up to resign the identity upon abnormal exit
+  auto *actorDecl = cast<ClassDecl>(ctor->getParent()->getAsDecl());
+  Cleanups.pushCleanup<ResignIdentity>(actorDecl, selfArg.getValue());
 }
 
 void SILGenFunction::emitDistributedActorReady(