[Distributed] move dist. init synthesis to default synthesis

Author: ktoso

include/swift/AST/DiagnosticsSema.def

@@ -4566,7 +4566,7 @@ ERROR(distributed_actor_func_not_in_distributed_actor,none,
       "'distributed' function can only be declared within 'distributed actor'",
       ())
 ERROR(distributed_actor_designated_ctor_must_have_one_transport_param,none,
-      "designated distributed actor initializer %0 must accept exactly one"
+      "designated distributed actor initializer %0 must accept exactly one "
       "ActorTransport parameter, found %1",
       (DeclName, int))
 ERROR(distributed_actor_designated_ctor_missing_transport_param,none,

lib/Sema/CodeSynthesis.cpp

@@ -209,10 +209,14 @@ enum class ImplicitConstructorKind {
   /// The default constructor, which default-initializes each
   /// of the instance variables.
   Default,
+  /// The default constructor of a distributed actor.
+  /// Similarly to a Default one it initializes each of the instance variables,
+  /// however it also implicitly gains an ActorTransport parameter.
+  DefaultDistributedActor,
   /// The memberwise constructor, which initializes each of
   /// the instance variables from a parameter of the same type and
   /// name.
-  Memberwise
+  Memberwise,
 };
 
 /// Create an implicit struct or class constructor.
@@ -227,16 +231,6 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
                                                   ASTContext &ctx) {
   assert(!decl->hasClangNode());
 
-  // Don't synthesize for distributed actors, they're a bit special.
-  //
-  // They have their special inits, and should not get the usual
-  // default/implicit constructor (i.e. `init()` is illegal for them, as they
-  // always must have an associated transport - via `init(transport:)` or
-  // `init(resolve:using:)`).
-  if (auto clazz = dyn_cast<ClassDecl>(decl))
-    if (clazz->isDistributedActor())
-      return nullptr;
-
   SourceLoc Loc = decl->getLoc();
   auto accessLevel = AccessLevel::Internal;
 
@@ -319,6 +313,23 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
 
       maybeAddMemberwiseDefaultArg(arg, var, params.size(), ctx);
 
+      params.push_back(arg);
+    }
+  } else if (ICK == ImplicitConstructorKind::DefaultDistributedActor) {
+    assert(isa<ClassDecl>(decl));
+    assert(decl->isDistributedActor() &&
+           "Only 'distributed actor' type can gain implicit distributed actor init");
+
+    if (swift::ensureDistributedModuleLoaded(decl)) {
+      auto transportDecl = ctx.getActorTransportDecl();
+
+      // Create the parameter.
+      auto *arg = new (ctx) ParamDecl(SourceLoc(), Loc, ctx.Id_transport, Loc,
+                                      ctx.Id_transport, transportDecl);
+      arg->setSpecifier(ParamSpecifier::Default);
+      arg->setInterfaceType(transportDecl->getDeclaredInterfaceType());
+      arg->setImplicit();
+
       params.push_back(arg);
     }
   }
@@ -1193,7 +1204,6 @@ static bool shouldAttemptInitializerSynthesis(const NominalTypeDecl *decl) {
 }
 
 void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
-  fprintf(stderr, "[%s:%d] (%s) ADD IMPLICIT\n", __FILE__, __LINE__, __FUNCTION__);
   // If we already added implicit initializers, we're done.
   if (decl->addedImplicitInitializers())
     return;
@@ -1493,10 +1503,10 @@ SynthesizeDefaultInitRequest::evaluate(Evaluator &evaluator,
                                   decl);
 
   // Create the default constructor.
-  if (auto ctor = createImplicitConstructor(decl,
-                                        ImplicitConstructorKind::Default,
-                                        ctx)) {
-
+  auto ctorKind = decl->isDistributedActor() ?
+      ImplicitConstructorKind::DefaultDistributedActor :
+      ImplicitConstructorKind::Default;
+  if (auto ctor = createImplicitConstructor(decl, ctorKind, ctx)) {
     // Add the constructor.
     decl->addMember(ctor);
 

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -119,25 +119,6 @@ createDistributedActor_init_default(ClassDecl *classDecl,
   return initDecl;
 }
 
-static void addImplicitDefaultDistributedActorConstructor(ClassDecl *decl) {
-  fprintf(stderr, "[%s:%d] (%s) addImplicitDefaultDistributedActorConstructor\n", __FILE__, __LINE__, __FUNCTION__);
-  decl->setAddedImplicitInitializers();
-
-  // Check whether the user has defined a designated initializer for this actor,
-  // if so, we will not synthesize the init(transport:) initializer.
-  bool foundDesignatedInit = decl->hasUserDefinedDesignatedInit();
-  if (foundDesignatedInit) {
-    fprintf(stderr, "[%s:%d] (%s) FOUND DESIGNATED INIT SKIP SYNTHESIS\n", __FILE__, __LINE__, __FUNCTION__);
-    decl->dump();
-    return;
-  }
-
-  fprintf(stderr, "[%s:%d] (%s) MAKE DESIGNATED INIT SYNTHESIS\n", __FILE__, __LINE__, __FUNCTION__);
-  auto &ctx = decl->getASTContext();
-  auto init = createDistributedActor_init_default(decl, ctx);
-  decl->addMember(init);
-}
-
 /******************************************************************************/
 /******************************** DEINIT **************************************/
 /******************************************************************************/
@@ -464,15 +445,10 @@ void swift::addImplicitDistributedActorMembersToClass(ClassDecl *decl) {
   if (!decl->isDistributedActor())
     return;
 
-  // === Ensure the _Distributed module is loaded
-  auto &C = decl->getASTContext();
-  if (!C.getLoadedModule(C.Id_Distributed)) {
-    // seems we're missing the _Distributed module, ask to import it explicitly
-    decl->diagnose(diag::distributed_actor_needs_explicit_distributed_import);
+  // If the _Distributed module is missing we cannot synthesize anything.
+  if (!swift::ensureDistributedModuleLoaded(decl))
     return;
-  }
 
-  addImplicitDefaultDistributedActorConstructor(decl);
   addImplicitDistributedActorStoredProperties(decl);
   addImplicitRemoteActorFunctions(decl);
 //  addImplicitResignIdentity(decl);

lib/Sema/TypeCheckDistributed.cpp

@@ -31,6 +31,20 @@ using namespace swift;
 
 // ==== ------------------------------------------------------------------------
 
+bool swift::ensureDistributedModuleLoaded(Decl *decl) {
+  fprintf(stderr, "[%s:%d] (%s) ensureDistributedModuleLoaded\n", __FILE__, __LINE__, __FUNCTION__);
+  auto &C = decl->getASTContext();
+  if (!C.getLoadedModule(C.Id_Distributed)) {
+    // seems we're missing the _Distributed module, ask to import it explicitly
+    decl->diagnose(diag::distributed_actor_needs_explicit_distributed_import);
+    return false;
+  }
+
+  return true;
+}
+
+// ==== ------------------------------------------------------------------------
+
 bool IsDistributedActorRequest::evaluate(
     Evaluator &evaluator, NominalTypeDecl *nominal) const {
   // Protocols are actors if they inherit from `DistributedActor`.
@@ -183,14 +197,21 @@ void TypeChecker::checkDistributedActor(const ClassDecl *decl) {
 
   auto mutableDecl = const_cast<ClassDecl*>(decl);
 
-  swift::addImplicitDistributedActorMembersToClass(mutableDecl);
+  // ==== Constructors
+  // --- Get the default initializer
+  // If applicable, this will the default 'init(transport:)' initializer
+  (void)mutableDecl->getDefaultInitializer();
 
-  for (auto member : decl->getMembers()) {
-    if (auto ctor = dyn_cast<ConstructorDecl>(member)) {
-      fprintf(stderr, "[%s:%d] (%s) CHECK CTOR\n", __FILE__, __LINE__, __FUNCTION__);
-      member->dump();
+  // --- Check all constructors
+  for (auto member : decl->getMembers())
+    if (auto ctor = dyn_cast<ConstructorDecl>(member))
       checkDistributedActorConstructor(decl, ctor);
-    }
-  }
+
+  // ==== Properties
+  // Synthesize properties
+  // TODO: those could technically move to DerivedConformance style
+  swift::addImplicitDistributedActorMembersToClass(mutableDecl);
+
+  // ==== Functions
 }
 

lib/Sema/TypeCheckDistributed.h

@@ -26,25 +26,20 @@ namespace swift {
 
 class AbstractFunctionDecl;
 class ConstructorDecl;
-class ActorIsolation;
-class AnyFunctionType;
 class ASTContext;
 class ClassDecl;
-class ClosureExpr;
-class ConcreteDeclRef;
-class CustomAttr;
 class Decl;
 class DeclContext;
-class EnumElementDecl;
 class Expr;
 class FuncDecl;
 class Initializer;
 class PatternBindingDecl;
 class ProtocolConformance;
-class TopLevelCodeDecl;
-class TypeBase;
 class ValueDecl;
 
+// Diagnose an error if the _Distributed module is not loaded.
+bool ensureDistributedModuleLoaded(Decl *decl);
+
 /// Check distributed actor isolation rules.
 
 /// The local and resolve distributed actor constructors have special rules to check.

test/Distributed/distributed_actor_initialization.swift

@@ -10,149 +10,57 @@ distributed actor OK0 { }
 @available(SwiftStdlib 5.5, *)
 distributed actor OK1 {
   var x: Int = 1
-  // ok, since all fields are initialized, the constructors can be synthesized
+  // ok, since all fields are initialized, the constructor can be synthesized
 }
 
-// TODO: test all the FIXITs in this file
+// TODO(distributed): test all the FIXITs in this file
 
 @available(SwiftStdlib 5.5, *)
 distributed actor Bad1 {
   init() {
-    // expected-error@-1 {{'distributed actor' initializer 'init()' must be 'convenience' initializer. Distributed actors have an implicitly synthesized designated 'init(transport:)' local-initializer, which other initializers must delegate to}}
-    // expected-error@-2 {{'distributed actor' initializer 'init()' must (directly or indirectly) delegate to 'init(transport:)}}
-  }
-}
-
-@available(SwiftStdlib 5.5, *)
-distributed actor Bad11 {
-  convenience init() {
-    // expected-error@-1 {{'distributed actor' initializer 'init()' must (directly or indirectly) delegate to 'init(transport:)'}}
+    // expected-error@-1 {{designated distributed actor initializer 'init()' is missing required ActorTransport parameter}}
   }
 }
 
 @available(SwiftStdlib 5.5, *)
 distributed actor Bad12 {
   init(x: String) {
-    // expected-error@-1 {{'distributed actor' initializer 'init(x:)' must be 'convenience' initializer. Distributed actors have an implicitly synthesized designated 'init(transport:)' local-initializer, which other initializers must delegate to}}
-    // expected-error@-2 {{'distributed actor' initializer 'init(x:)' must (directly or indirectly) delegate to 'init(transport:)}}
+    // expected-error@-1 {{designated distributed actor initializer 'init(x:)' is missing required ActorTransport parameter}}
   }
 }
 
 @available(SwiftStdlib 5.5, *)
 distributed actor OK2 {
   var x: Int
 
-  convenience init(x: Int, transport: ActorTransport) {
-    self.init(transport: transport)
+  init(x: Int, transport: ActorTransport) { // ok
     self.x = x
   }
 }
 
 @available(SwiftStdlib 5.5, *)
 distributed actor Bad2 {
-  var x: Int
+  var x: Int = 1
 
-  convenience init(x: Int, transport: ActorTransport) {
-    self.init(transport: transport)
-    self.x = x
+  init(transport: ActorTransport, too many: ActorTransport) {
+    // expected-error@-1{{designated distributed actor initializer 'init(transport:too:)' must accept exactly one ActorTransport parameter, found 2}}
   }
 }
 
 @available(SwiftStdlib 5.5, *)
-distributed actor Bad3 {
+distributed actor OK3 {
   var x: Int
 
-  convenience init(y: Int, transport: ActorTransport) {
-    // expected-error@-1 {{'distributed actor' initializer 'init(y:transport:)' must (directly or indirectly) delegate to 'init(transport:)'}}
-    // forgot to delegate to init(transport:)
+  init(y: Int, transport: ActorTransport) {
     self.x = y
   }
 }
 
 @available(SwiftStdlib 5.5, *)
 distributed actor OKMulti {
-  // @derived init(transport:)
 
   convenience init(y: Int, transport: ActorTransport) { // ok
     self.init(transport: transport)
   }
 
-  convenience init(x: Int, y: Int, transport: ActorTransport) {
-    // ok, since we do delegate to init(transport) *eventually*
-    self.init(y: y, transport: transport)
-  }
-}
-
-@available(SwiftStdlib 5.5, *)
-distributed actor BadMulti {
-  // @derived init(transport:)
-
-  convenience init(y: Int, transport: ActorTransport) {
-    // expected-error@-1 {{'distributed actor' initializer 'init(y:transport:)' must (directly or indirectly) delegate to 'init(transport:)'}}
-    // self.init(transport: transport) // forgot to delegate to local init!
-  }
-
-  convenience init(x: Int, y: Int, transport: ActorTransport) {
-    // expected-error@-1 {{'distributed actor' initializer 'init(x:y:transport:)' must (directly or indirectly) delegate to 'init(transport:)'}}
-    // ok, since we do delegate to init(transport) *eventually*
-    self.init(y: y, transport: transport)
-  }
-}
-
-// It is illegal to manually invoke the resolve initializer,
-// because it may result in "not a real instance" i.e. a proxy
-// and a proxy does not have any storage, so it would be wrong to allow other
-// initializers to keep running while we actually created a proxy with no storage.
-@available(SwiftStdlib 5.5, *)
-distributed actor BadResolveInitCall {
-  convenience init(any: Any, id: AnyActorIdentity, transport: ActorTransport) throws {
-    // expected-error@-1 {{'distributed actor' initializer 'init(any:id:transport:)' cannot delegate to resolve-initializer 'init(resolve:using:)', as it may result resolving a storageless proxy instance}}
-    // expected-error@-2 {{'distributed actor' initializer 'init(any:id:transport:)' must (directly or indirectly) delegate to 'init(transport:)'}}
-    try self.init(resolve: id, using: transport) // TODO: suggest removing this call, since it is illegal
-  }
-}
-
-@available(SwiftStdlib 5.5, *)
-distributed actor BadRedeclare1 { // expected-error {{type 'BadRedeclare1' does not conform to protocol 'DistributedActor'}}
-  convenience init(transport: ActorTransport) {}
-  // expected-error@-1 {{'distributed actor' local-initializer 'init(transport:)' cannot be implemented explicitly}}
-  // expected-error@-2 {{invalid redeclaration of synthesized 'init(transport:)'}}
-  // expected-error@-3 {{invalid redeclaration of synthesized initializer 'init(transport:)'}}
-  // expected-note@-4 {{candidate exactly matches}}
-}
-
-@available(SwiftStdlib 5.5, *)
-distributed actor BadRedeclare11 { // expected-error {{type 'BadRedeclare11' does not conform to protocol 'DistributedActor'}}
-  convenience init(transport xxx: ActorTransport) {}
-  // expected-error@-1 {{'distributed actor' local-initializer 'init(transport:)' cannot be implemented explicitly}}
-  // expected-error@-2 {{invalid redeclaration of synthesized 'init(transport:)'}}
-  // expected-error@-3 {{invalid redeclaration of synthesized initializer 'init(transport:)'}}
-  // expected-note@-4 {{candidate exactly matches}}
-}
-
-@available(SwiftStdlib 5.5, *)
-distributed actor BadRedeclare2 { // expected-error {{type 'BadRedeclare2' does not conform to protocol 'DistributedActor'}}
-  convenience init(resolve id: AnyActorIdentity, using transport: ActorTransport) {}
-  // expected-error@-1 {{'distributed actor' resolve-initializer 'init(resolve:using:)' cannot be implemented explicitly}}
-  // expected-note@-2 {{candidate exactly matches}}
-  // expected-error@-3 {{invalid redeclaration of synthesized 'init(resolve:using:)'}}
-  // expected-error@-4 {{invalid redeclaration of synthesized initializer 'init(resolve:using:)'}}
-}
-
-@available(SwiftStdlib 5.5, *)
-distributed actor BadRedeclare21 { //expected-error {{type 'BadRedeclare21' does not conform to protocol 'DistributedActor'}}
-  convenience init(resolve xxx: AnyActorIdentity, using yyy: ActorTransport) {}
-  // expected-error@-1 {{'distributed actor' resolve-initializer 'init(resolve:using:)' cannot be implemented explicitly}}
-  // expected-note@-2 {{candidate exactly matches}}
-  // expected-error@-3 {{invalid redeclaration of synthesized 'init(resolve:using:)'}}
-  // expected-error@-4 {{invalid redeclaration of synthesized initializer 'init(resolve:using:)'}}
-}
-
-@available(SwiftStdlib 5.5, *)
-distributed actor BadRedeclare22 { //expected-error {{type 'BadRedeclare22' does not conform to protocol 'DistributedActor'}}
-  convenience init(resolve: AnyActorIdentity, using yyy: ActorTransport) throws {}
-  // expected-error@-1 {{'distributed actor' resolve-initializer 'init(resolve:using:)' cannot be implemented explicitly}}
-  // expected-note@-2 {{candidate exactly matches}}
-  // expected-error@-3 {{invalid redeclaration of synthesized 'init(resolve:using:)'}}
-  // expected-error@-4 {{invalid redeclaration of synthesized initializer 'init(resolve:using:)'}}
 }