remove dependence on system parameter in SILGen/DefiniteInit

Author: kavon

include/swift/SILOptimizer/Utils/DistributedActor.h

@@ -32,10 +32,6 @@ class SILLocation;
 class SILType;
 class SILValue;
 
-/// Finds the first `DistributedActorSystem`-compatible parameter of the given function.
-/// \returns nullptr if the function does not have such a parameter.
-SILArgument *findFirstDistributedActorSystemArg(SILFunction &F);
-
 /// Emit a call to a witness of the DistributedActorSystem protocol.
 ///
 /// \param methodName The name of the method on the DistributedActorSystem protocol.

lib/SILGen/SILGenConstructor.cpp

@@ -835,7 +835,7 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     }
   }
 
-  // Distributed actor initializers implicitly initialize their transport and id
+  // Some distributed actor initializers need to init the actorSystem & id now
   if (isDesignatedDistActorInit) {
     emitDistributedActorImplicitPropertyInits(ctor, selfArg);
   }
@@ -1257,4 +1257,3 @@ void SILGenFunction::emitIVarInitializer(SILDeclRef ivarInitializer) {
 
   emitEpilog(loc);
 }
-

lib/SILGen/SILGenDistributed.cpp

@@ -133,18 +133,56 @@ static void emitDistributedIfRemoteBranch(SILGenFunction &SGF, SILLocation Loc,
 // ==== ------------------------------------------------------------------------
 // MARK: local instance initialization
 
+static SILArgument *findFirstDistributedActorSystemArg(SILFunction &F) {
+  auto *module = F.getModule().getSwiftModule();
+  auto &C = F.getASTContext();
+
+  auto *transportProto = C.getProtocol(KnownProtocolKind::DistributedActorSystem);
+  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();
+
+    auto conformsToTransport =
+        module->lookupConformance(argDecl->getInterfaceType(), transportProto);
+
+    // Is it a protocol that conforms to DistributedActorSystem?
+    if (argTy->isEqual(transportTy) || conformsToTransport) {
+      return arg;
+    }
+
+    // Is it some specific DistributedActorSystem?
+    auto result = module->lookupConformance(argTy, transportProto);
+    if (!result.isInvalid()) {
+      return arg;
+    }
+  }
+
+#ifndef NDEBUG
+  llvm_unreachable("Missing required DistributedActorSystem argument!");
+#endif
+
+  return nullptr;
+}
+
 /// For the initialization of a local distributed actor instance, emits code to
 /// initialize the instance's stored property corresponding to the system.
 static void emitActorSystemInit(SILGenFunction &SGF,
                                         ConstructorDecl *ctor,
                                         SILLocation loc,
                                         ManagedValue actorSelf) {
+  assert(ctor->isImplicit() && "unexpected explicit dist actor init");
+  assert(ctor->isDesignatedInit());
+
   auto *dc = ctor->getDeclContext();
   auto classDecl = dc->getSelfClassDecl();
   auto &C = ctor->getASTContext();
 
-  // Sema has already guaranteed that there is exactly one DistributedActorSystem
-  // argument to the constructor, so we grab the first one from the params.
+  // By construction, automatically generated distributed actor ctors have
+  // exactly one ActorSystem-conforming argument to the constructor,
+  // so we grab the first one from the params.
   SILValue systemArg = findFirstDistributedActorSystemArg(SGF.F);
   VarDecl *var = lookupProperty(classDecl, C.Id_actorSystem);
   assert(var);
@@ -160,6 +198,9 @@ static void emitActorSystemInit(SILGenFunction &SGF,
 /// \endverbatim
 static void emitIDInit(SILGenFunction &SGF, ConstructorDecl *ctor,
                              SILLocation loc, ManagedValue borrowedSelfArg) {
+  assert(ctor->isImplicit() && "unexpected explicit dist actor init");
+  assert(ctor->isDesignatedInit());
+
   auto &C = ctor->getASTContext();
   auto &B = SGF.B;
   auto &F = SGF.F;
@@ -173,7 +214,8 @@ static void emitIDInit(SILGenFunction &SGF, ConstructorDecl *ctor,
   auto selfMetatype = SGF.getLoweredType(MetatypeType::get(selfTy));
   SILValue selfMetatypeValue = B.createMetatype(loc, selfMetatype);
 
-  SILValue actorSystem = findFirstDistributedActorSystemArg(F);
+  // since we're doing this only for the implicitly defined ctors, grab from arg
+  SILValue actorSystem = findFirstDistributedActorSystemArg(SGF.F);
 
   // --- create a temporary storage for the result of the call
   // it will be deallocated automatically as we exit this scope
@@ -230,12 +272,19 @@ void SILGenFunction::emitDistributedActorImplicitPropertyInits(
   loc.markAutoGenerated();
 
   selfArg = selfArg.borrow(*this, loc);
-  emitActorSystemInit(*this, ctor, loc, selfArg);
-  emitIDInit(*this, ctor, loc, selfArg);
 
   // register a clean-up to resign the identity upon abnormal exit
+  // we do this regardless of initializer kind, since it's easy to do in SILGen.
   auto *actorDecl = cast<ClassDecl>(ctor->getParent()->getAsDecl());
   Cleanups.pushCleanup<ResignIdentity>(actorDecl, selfArg.getValue());
+
+  // Users must initialize the actorSystem property explicitly in their ctors
+  if (!ctor->isImplicit())
+    return;
+
+  // implicit ctors initialize these from the ActorSystem parameter.
+  emitActorSystemInit(*this, ctor, loc, selfArg);
+  emitIDInit(*this, ctor, loc, selfArg);
 }
 
 void SILGenFunction::emitDistributedActorReady(
@@ -244,12 +293,27 @@ void SILGenFunction::emitDistributedActorReady(
   // Only designated initializers get the lifecycle handling injected
   assert(ctor->isDesignatedInit());
 
-  SILValue transport = findFirstDistributedActorSystemArg(F);
+  auto &C = ctor->getASTContext();
+  auto *dc = ctor->getDeclContext();
+  auto classDecl = dc->getSelfClassDecl();
 
   FullExpr scope(Cleanups, CleanupLocation(loc));
   auto borrowedSelf = actorSelf.borrow(*this, loc);
 
-  emitActorReadyCall(B, loc, borrowedSelf.getValue(), transport);
+  // --- load the actor system from the actor instance
+  ManagedValue actorSystem;
+  SGFContext sgfCxt; // TODO: is this right?
+  {
+    VarDecl *property = lookupProperty(classDecl, C.Id_actorSystem);
+    Type formalType = F.mapTypeIntoContext(property->getInterfaceType());
+    SILType loweredType = getLoweredType(formalType).getAddressType();
+    SILValue actorSystemRef = emitActorPropertyReference(
+                                *this, loc, borrowedSelf.getValue(), property);
+    actorSystem = emitLoad(loc, actorSystemRef,
+                           getTypeLowering(loweredType), sgfCxt, IsNotTake);
+  }
+
+  emitActorReadyCall(B, loc, borrowedSelf.getValue(), actorSystem.getValue());
 }
 
 // ==== ------------------------------------------------------------------------

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -787,6 +787,42 @@ static bool isDistributedActorCtor(SILFunction &F) {
   return false;
 }
 
+//static SILValue emitActorPropertyReference(
+//    SILGenFunction &SGF, SILLocation loc, SILValue actorSelf,
+//    VarDecl *property) {
+//  Type formalType = SGF.F.mapTypeIntoContext(property->getInterfaceType());
+//  SILType loweredType = SGF.getLoweredType(formalType).getAddressType();
+//  return SGF.B.createRefElementAddr(loc, actorSelf, property, loweredType);
+//}
+
+/// Creates a reference to the distributed actor's \p actorSystem
+/// stored property.
+static SILValue refDistributedActorSystem(SILLocation loc,
+                                           SILBuilder &b,
+                                           SILValue actorInstance,
+                                           SILFunction &F) {
+  ClassDecl *clsDecl = F.getDeclContext()->getSelfClassDecl();
+  assert(clsDecl->isDistributedActor());
+
+  // get the VarDecl corresponding to the actorSystem.
+  auto refs = clsDecl->lookupDirect(clsDecl->getASTContext().Id_actorSystem);
+  assert(refs.size() == 1);
+  VarDecl *actorSystemVar = dyn_cast<VarDecl>(refs.front());
+
+  return b.createRefElementAddr(loc, actorInstance, actorSystemVar);
+}
+
+static void loadCopyWithCleanups(SILLocation loc, SILBuilder& b, SILValue ref,
+                                 llvm::function_ref<void(SILValue)> scope) {
+  auto copy = b.createLoad(loc, ref, LoadOwnershipQualifier::Copy);
+  auto borrow = b.createBeginBorrow(loc, copy);
+
+  scope(borrow);
+
+  b.createEndBorrow(loc, borrow);
+  b.createDestroyValue(loc, copy);
+}
+
 /// Injects a hop_to_executor instruction after the specified insertion point.
 static void injectHopToExecutorAfter(SILLocation loc,
                                      SILBasicBlock::iterator insertPt,
@@ -806,29 +842,32 @@ static void injectHopToExecutorAfter(SILLocation loc,
     LLVM_DEBUG(llvm::dbgs() << "hop-injector: injecting after " << *insertPt);
     SILBuilderWithScope::insertAfter(insertPt, [&](SILBuilder &b) {
 
+      SILLocation genLoc = loc.asAutoGenerated();
       const bool delegating = !TheMemory.isNonDelegatingInit();
       SILValue val = TheMemory.getUninitializedValue();
 
       // delegating inits always have an alloc we need to load it from.
       if (delegating)
-        val = b.createLoad(loc.asAutoGenerated(), val,
-                           LoadOwnershipQualifier::Copy);
+        val = b.createLoad(genLoc, val, LoadOwnershipQualifier::Copy);
 
-      SILValue actor = b.createBeginBorrow(loc.asAutoGenerated(), val);
+      SILValue actor = b.createBeginBorrow(genLoc, val);
 
       b.createHopToExecutor(loc.asAutoGenerated(), actor, /*mandatory=*/false);
 
       // Distributed actors also need to notify their transport immediately
       // after performing the hop.
       if (!delegating && isDistributedActorCtor(b.getFunction())) {
-        auto transport = findFirstDistributedActorSystemArg(b.getFunction());
-        emitActorReadyCall(b, loc.asAutoGenerated(), actor, transport);
+        SILValue systemRef = refDistributedActorSystem(loc.asAutoGenerated(),
+                                                     b, actor, b.getFunction());
+        loadCopyWithCleanups(genLoc, b, systemRef, [&](SILValue systemVal) {
+          emitActorReadyCall(b, genLoc, actor, systemVal);
+        });
       }
 
-      b.createEndBorrow(loc.asAutoGenerated(), actor);
+      b.createEndBorrow(genLoc, actor);
 
       if (delegating)
-        b.createDestroyValue(loc.asAutoGenerated(), val);
+        b.createDestroyValue(genLoc, val);
     });
   };
 

lib/SILOptimizer/Utils/DistributedActor.cpp

@@ -18,40 +18,6 @@
 
 namespace swift {
 
-SILArgument *findFirstDistributedActorSystemArg(SILFunction &F) {
-  auto *module = F.getModule().getSwiftModule();
-  auto &C = F.getASTContext();
-
-  auto *transportProto = C.getProtocol(KnownProtocolKind::DistributedActorSystem);
-  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();
-
-    auto conformsToTransport =
-        module->lookupConformance(argDecl->getInterfaceType(), transportProto);
-
-    // Is it a protocol that conforms to DistributedActorSystem?
-    if (argTy->isEqual(transportTy) || conformsToTransport) {
-      return arg;
-    }
-
-    // Is it some specific DistributedActorSystem?
-    auto result = module->lookupConformance(argTy, transportProto);
-    if (!result.isInvalid()) {
-      return arg;
-    }
-  }
-
-#ifndef NDEBUG
-  llvm_unreachable("Missing required DistributedActorSystem argument!");
-#endif
-
-  return nullptr;
-}
-
 void emitDistributedActorSystemWitnessCall(
     SILBuilder &B, SILLocation loc, DeclName methodName,
     SILValue base,