[Distributed] move where we invoke dist synthesis; detect transport param

Author: ktoso

include/swift/AST/Decl.h

@@ -3367,7 +3367,11 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// for types that are not global actors.
   VarDecl *getGlobalActorInstance() const;
 
-  bool hasDistributedActorLocalInitializer() const;
+  /// Check if the declaration has an user-defined initializer.
+  /// If so, we may want to e.g. not generate a default initializer etc.
+  ///
+  /// \returns true if the decl has an user-defined designated initializer.
+  bool hasUserDefinedDesignatedInit() const;
 
   /// Whether this type is a global actor, which can be used as an
   /// attribute to decorate declarations for inclusion in the actor-isolated

include/swift/AST/DiagnosticsSema.def

@@ -4581,6 +4581,14 @@ ERROR(distributed_actor_func_static,none,
 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"
+      "ActorTransport parameter, found %1",
+      (DeclName, int))
+ERROR(distributed_actor_designated_ctor_missing_transport_param,none,
+      "designated distributed actor initializer %0 is missing required "
+      "ActorTransport parameter",
+      (DeclName))
 ERROR(distributed_actor_independent_property_must_be_let,none,
       "_distributedActorIndependent can be applied to properties, however they must be 'let'",
       ())

include/swift/AST/TypeCheckRequests.h

@@ -2065,6 +2065,7 @@ enum class ImplicitMemberAction : uint8_t {
   ResolveDecodable,
   ResolveDistributedActor,
   ResolveDistributedActorIdentity,
+  ResolveDistributedActorTransport,
 };
 
 class ResolveImplicitMemberRequest

lib/AST/Decl.cpp

@@ -4208,10 +4208,15 @@ ConstructorDecl *NominalTypeDecl::getDefaultInitializer() const {
                            SynthesizeDefaultInitRequest{mutableThis}, nullptr);
 }
 
-bool NominalTypeDecl::hasDistributedActorLocalInitializer() const {
+bool NominalTypeDecl::hasUserDefinedDesignatedInit() const {
+  // Imported decls don't have a designated initializer defined by the user.
+  if (hasClangNode())
+    return false;
+
   auto &ctx = getASTContext();
   auto *mutableThis = const_cast<NominalTypeDecl *>(this);
-  return evaluateOrDefault(ctx.evaluator, HasDistributedActorLocalInitRequest{mutableThis},
+  return evaluateOrDefault(ctx.evaluator,
+                           HasUserDefinedDesignatedInitRequest{mutableThis},
                            false);
 }
 
@@ -4242,7 +4247,7 @@ void NominalTypeDecl::synthesizeSemanticMembersIfNeeded(DeclName member) {
         if ((member.isSimpleName() || argumentNames.front() == Context.Id_from)) {
           action.emplace(ImplicitMemberAction::ResolveDecodable);
         } else if (argumentNames.front() == Context.Id_transport) {
-          action.emplace(ImplicitMemberAction::ResolveDistributedActor);
+          action.emplace(ImplicitMemberAction::ResolveDistributedActorTransport);
         }
       } else if (!baseName.isSpecial() &&
            baseName.getIdentifier() == Context.Id_encode &&

lib/AST/TypeCheckRequests.cpp

@@ -1034,11 +1034,14 @@ void swift::simple_display(llvm::raw_ostream &out,
     out << "resolve Decodable.init(from:)";
     break;
   case ImplicitMemberAction::ResolveDistributedActor:
-    out << "resolve DistributedActor[init(transport:), init(resolve:using:)]";
+    out << "resolve DistributedActor";
     break;
   case ImplicitMemberAction::ResolveDistributedActorIdentity:
     out << "resolve DistributedActor.id";
     break;
+  case ImplicitMemberAction::ResolveDistributedActorTransport:
+    out << "resolve DistributedActor.actorTransport";
+    break;
   }
 }
 

lib/SILGen/SILGenDistributed.cpp

@@ -36,6 +36,44 @@ using namespace Lowering;
 /****************** DISTRIBUTED ACTOR STORAGE INITIALIZATION ******************/
 /******************************************************************************/
 
+/// Get the `ActorTransport` parameter of the constructor.
+/// Sema should have guaranteed that there is exactly one of them for any
+/// designated initializer of a distributed actor.
+static SILArgument*
+getActorTransportArgument(ASTContext& C, SILFunction& F, ConstructorDecl *ctor) {
+  auto *DC = cast<DeclContext>(ctor);
+  auto module = DC->getParentModule();
+
+  auto *transportProto =
+      C.getProtocol(KnownProtocolKind::ActorTransport);
+  Type transportTy = transportProto->getDeclaredInterfaceType();
+
+  for (auto arg : F.getArguments()) {
+    // TODO(distributed): also be able to locate a generic transport
+    Type argTy = arg->getType().getASTType();
+    auto argDecl = arg->getDecl();
+    argTy->dump();
+    argDecl->dump();
+
+    auto conformsToTransport = module->lookupConformance(
+        argDecl->getInterfaceType(), transportProto);
+
+    // Is it a protocol that conforms to ActorTransport?
+    if (argTy->isEqual(transportTy) || conformsToTransport) {
+      return arg;
+    }
+
+    // Is it some specific ActorTransport?
+    auto result = module->lookupConformance(argTy, transportProto);
+    if (!result.isInvalid()) {
+      return arg;
+    }
+  }
+
+  // did not find argument of ActorTransport type!
+  llvm_unreachable("Missing required ActorTransport argument!");
+}
+
 
 static AbstractFunctionDecl*
 lookupAssignIdentityFunc(ASTContext& C) {
@@ -56,8 +94,11 @@ lookupAssignIdentityFunc(ASTContext& C) {
 /// // }
 /// \endverbatim
 static void
-emitDistributedActorTransportInit(SILGenFunction &SGF, ManagedValue borrowedSelfArg, VarDecl *selfDecl, ConstructorDecl *ctor,
-                                  Pattern *pattern, VarDecl *var) {
+emitDistributedActorTransportInit(
+    SILGenFunction &SGF,
+    ManagedValue borrowedSelfArg, VarDecl *selfDecl,
+    ConstructorDecl *ctor,
+    Pattern *pattern, VarDecl *var) {
   auto &C = selfDecl->getASTContext();
   auto &B = SGF.B;
   auto &F = SGF.F;
@@ -71,7 +112,7 @@ emitDistributedActorTransportInit(SILGenFunction &SGF, ManagedValue borrowedSelf
   SGF.F.dump();
 
   // ==== Prepare assignment: get the self.transport address
-  SILValue transportArgValue = F.getArgument(0);
+  SILValue transportArgValue = getActorTransportArgument(C, F, ctor);
   ManagedValue transportArgManaged = ManagedValue::forUnmanaged(transportArgValue);
   auto transportDecl = C.getActorTransportDecl();
 
@@ -96,10 +137,11 @@ emitDistributedActorTransportInit(SILGenFunction &SGF, ManagedValue borrowedSelf
 /// // }
 /// \endverbatim
 static void
-emitDistributedActorIdentityInit(SILGenFunction &SGF,
-                                 ManagedValue borrowedSelfArg,
-                                 VarDecl *selfVarDecl, ConstructorDecl *ctor,
-                                 Pattern *pattern, VarDecl *var) {
+emitDistributedActorIdentityInit(
+    SILGenFunction &SGF,
+    ManagedValue borrowedSelfArg, VarDecl *selfVarDecl,
+    ConstructorDecl *ctor,
+    Pattern *pattern, VarDecl *var) {
   auto &C = selfVarDecl->getASTContext();
   auto &B = SGF.B;
   auto &F = SGF.F;
@@ -120,8 +162,8 @@ emitDistributedActorIdentityInit(SILGenFunction &SGF,
   auto assignIdentityFnRef = SILDeclRef(assignIdentityFuncDecl);
 
   // === Open the transport existential before call
-  SILValue transportArgValue = F.getArgument(0);
-  SILValue selfArgValue = F.getArgument(1);
+  SILValue transportArgValue = getActorTransportArgument(C, F, ctor);
+  SILValue selfArgValue = F.getSelfArgument();
   ProtocolDecl *distributedActorProto = C.getProtocol(KnownProtocolKind::DistributedActor);
   ProtocolDecl *transportProto = C.getProtocol(KnownProtocolKind::ActorTransport);
   assert(distributedActorProto);
@@ -137,8 +179,6 @@ emitDistributedActorIdentityInit(SILGenFunction &SGF,
       loc, transportArgValue, openedTransportSILType, OpenedExistentialAccess::Immutable);
 
   // --- prepare `Self.self` metatype
-  // TODO: how to get @dynamic_self, do we need it?
-  //       %14 = metatype $@thick @dynamic_self DA_DefaultDeinit.Type // type-defs: %1; user: %16
   auto *selfTyDecl = ctor->getParent()->getSelfNominalTypeDecl();
   // This would be bad: since not ok for generic
   // auto selfMetatype = SGF.getLoweredType(selfTyDecl->getInterfaceType());
@@ -162,11 +202,6 @@ emitDistributedActorIdentityInit(SILGenFunction &SGF,
   auto transportConfRef = ProtocolConformanceRef(transportProto);
   assert(!transportConfRef.isInvalid() && "Missing conformance to `ActorTransport`");
 
-//  fprintf(stderr, "[%s:%d] (%s) selfArg->getType()\n", __FILE__, __LINE__, __FUNCTION__);
-//  selfArg.getType().dump();
-//  fprintf(stderr, "[%s:%d] (%s) distributedActorProto\n", __FILE__, __LINE__, __FUNCTION__);
-//  distributedActorProto->dump();
-
   auto selfTy = F.mapTypeIntoContext(selfTyDecl->getDeclaredInterfaceType()); // TODO: thats just self var devl getType
 
   auto distributedActorConfRef = module->lookupConformance(
@@ -236,6 +271,13 @@ void SILGenFunction::initializeDistributedActorImplicitStorageInit(
   auto classDecl = dc->getSelfClassDecl();
   auto &C = classDecl->getASTContext();
 
+  // Only designated initializers get the lifecycle handling injected
+  if (!ctor->isDesignatedInit()) {
+    fprintf(stderr, "[%s:%d] (%s) NOT DESIGNATED INIT SKIP\n", __FILE__, __LINE__, __FUNCTION__);
+
+    return;
+  }
+
   SILLocation prologueLoc = RegularLocation(ctor);
   prologueLoc.markAsPrologue(); // TODO: no idea if this is necessary or makes sense
 

lib/Sema/CodeSynthesis.cpp

@@ -985,6 +985,8 @@ HasUserDefinedDesignatedInitRequest::evaluate(Evaluator &evaluator,
   return false;
 }
 
+// TODO(distributed): duplicated of NominalTypeDecl::hasUserDefinedDesignatedInit,
+//                    remove this static version?
 static bool hasUserDefinedDesignatedInit(Evaluator &eval,
                                          NominalTypeDecl *decl) {
   // Imported decls don't have a designated initializer defined by the user.
@@ -1191,6 +1193,7 @@ 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;
@@ -1202,7 +1205,6 @@ void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
 
   if (auto *classDecl = dyn_cast<ClassDecl>(decl)) {
     addImplicitInheritedConstructorsToClass(classDecl);
-    addImplicitDistributedActorMembersToClass(classDecl); // FIXME(distributed): add always this is not just constructors
   }
 
   // Force the memberwise and default initializers if the type has them.
@@ -1286,18 +1288,20 @@ ResolveImplicitMemberRequest::evaluate(Evaluator &evaluator,
   }
     break;
   case ImplicitMemberAction::ResolveDistributedActor:
+  case ImplicitMemberAction::ResolveDistributedActorTransport:
   case ImplicitMemberAction::ResolveDistributedActorIdentity: {
     // init(transport:) and init(resolve:using:) may be synthesized as part of
     // derived conformance to the DistributedActor protocol.
     // If the target should conform to the DistributedActor protocol, check the
     // conformance here to attempt synthesis.
-    TypeChecker::addImplicitConstructors(target);
+    // FIXME(distributed): invoke the requirement adding explicitly here
+     TypeChecker::addImplicitConstructors(target);
     auto *distributedActorProto =
         Context.getProtocol(KnownProtocolKind::DistributedActor);
     (void)evaluateTargetConformanceTo(distributedActorProto);
-  }
     break;
   }
+  }
   return std::make_tuple<>();
 }