[Distributed] allow hop-to let any: any X where X is DistActor

Author: ktoso

include/swift/AST/DistributedDecl.h

@@ -37,7 +37,7 @@ class NominalTypeDecl;
 Type getConcreteReplacementForProtocolActorSystemType(ValueDecl *member);
 
 /// Determine the `ActorSystem` type for the given actor.
-Type getDistributedActorSystemType(NominalTypeDecl *actor);
+Type getDistributedActorSystemType(ClassDecl *actor);
 
 /// Determine the `ID` type for the given actor.
 Type getDistributedActorIDType(NominalTypeDecl *actor);

lib/AST/ASTContext.cpp

@@ -1258,24 +1258,25 @@ FuncDecl *ASTContext::getEqualIntDecl() const {
   return getBinaryComparisonOperatorIntDecl(*this, "==", getImpl().EqualIntDecl);
 }
 
-AbstractFunctionDecl *ASTContext::getRemoteCallOnDistributedActorSystem(
-    NominalTypeDecl *actorOrSystem, bool isVoidReturn) const {
-  assert(actorOrSystem && "distributed actor (or system) decl must be provided");
-  const NominalTypeDecl *system = actorOrSystem;
-  if (actorOrSystem->isDistributedActor()) {
-    auto var = actorOrSystem->getDistributedActorSystemProperty();
-    system = var->getInterfaceType()->getAnyNominal();
-  }
-
-  if (!system)
-    system = getProtocol(KnownProtocolKind::DistributedActorSystem);
-
-  auto mutableSystem = const_cast<NominalTypeDecl *>(system);
-  return evaluateOrDefault(
-      system->getASTContext().evaluator,
-      GetDistributedActorSystemRemoteCallFunctionRequest{mutableSystem, /*isVoidReturn=*/isVoidReturn},
-      nullptr);
-}
+//AbstractFunctionDecl *ASTContext::getRemoteCallOnDistributedActorSystem(
+//    NominalTypeDecl *actorOrSystem, bool isVoidReturn) const {
+//  assert(actorOrSystem && "distributed actor (or system) decl must be provided");
+//  const NominalTypeDecl *system = actorOrSystem;
+//  if (actorOrSystem->isDistributedActor()) {
+//
+//    auto var = actorOrSystem->getDistributedActorSystemProperty();
+//    system = var->getInterfaceType()->getAnyNominal();
+//  }
+//
+//  if (!system)
+//    system = getProtocol(KnownProtocolKind::DistributedActorSystem);
+//
+//  auto mutableSystem = const_cast<NominalTypeDecl *>(system);
+//  return evaluateOrDefault(
+//      system->getASTContext().evaluator,
+//      GetDistributedActorSystemRemoteCallFunctionRequest{mutableSystem, /*isVoidReturn=*/isVoidReturn},
+//      nullptr);
+//}
 
 FuncDecl *ASTContext::getMakeInvocationEncoderOnDistributedActorSystem(
     AbstractFunctionDecl *thunk) const {

lib/AST/DistributedDecl.cpp

@@ -70,7 +70,18 @@ Type swift::getConcreteReplacementForProtocolActorSystemType(ValueDecl *member)
   auto *DC = member->getDeclContext();
   auto DA = C.getDistributedActorDecl();
 
-  if (auto *protocol = DC->getSelfProtocolDecl()) {
+  // === When declared inside a n actor, we can get the type directly
+  if (auto classDecl = dyn_cast<ClassDecl>(DC)) {
+    return getDistributedActorSystemType(classDecl);
+  }
+
+  /// === Maybe the value is declared in a protocol?
+  ProtocolDecl *protocol = dyn_cast<ProtocolDecl>(member);
+  if (!protocol) {
+    protocol = DC->getSelfProtocolDecl();
+  }
+
+  if (protocol) {
     GenericSignature signature;
     if (auto *genericContext = member->getAsGenericContext()) {
       signature = genericContext->getGenericSignature();
@@ -84,30 +95,25 @@ Type swift::getConcreteReplacementForProtocolActorSystemType(ValueDecl *member)
     auto systemTy = signature->getConcreteType(ActorSystemAssocType);
     assert(systemTy && "couldn't find concrete type for actor system");
     return systemTy;
-  } else if (auto classDecl = dyn_cast<ClassDecl>(DC)) {
-      if (!classDecl)
-        return Type();
-
-      return getDistributedActorSystemType(classDecl);
   }
 
   llvm_unreachable("Unable to fetch ActorSystem type!");
 }
 
-Type swift::getDistributedActorSystemType(NominalTypeDecl *nominal) {
-  assert(!isa<ProtocolDecl>(nominal) && "FIXME: we should deal with it here too or collapse the two impls");
-  assert(nominal->isDistributedActor());
-  auto &C = nominal->getASTContext();
-  auto *DC = nominal->getDeclContext();
+Type swift::getDistributedActorSystemType(ClassDecl *actor) {
+//  assert(!isa<ProtocolDecl>(nominal) && "FIXME: we should deal with it here too or collapse the two impls");
+  assert(actor->isDistributedActor());
+  auto &C = actor->getASTContext();
+  auto *DC = actor->getDeclContext();
 
-  auto DAP = C.getDistributedActorDecl();
-  if (!DAP)
+  auto DA = C.getDistributedActorDecl();
+  if (!DA)
     return ErrorType::get(C);
 
   // Dig out the actor system type.
-  auto module = nominal->getParentModule();
-  Type selfType = nominal->getSelfInterfaceType();
-  auto conformance = module->lookupConformance(selfType, DAP);
+  auto module = actor->getParentModule();
+  Type selfType = actor->getSelfInterfaceType();
+  auto conformance = module->lookupConformance(selfType, DA);
   return conformance.getTypeWitnessByName(selfType, C.Id_ActorSystem);
 }
 
@@ -1055,6 +1061,31 @@ NominalTypeDecl::getDistributedRemoteCallTargetInitFunction() const {
       GetDistributedRemoteCallTargetInitFunctionRequest(mutableThis), nullptr);
 }
 
+AbstractFunctionDecl *ASTContext::getRemoteCallOnDistributedActorSystem(
+    NominalTypeDecl *actorOrSystem, bool isVoidReturn) const {
+  assert(actorOrSystem && "distributed actor (or system) decl must be provided");
+  const NominalTypeDecl *system = actorOrSystem;
+  if (actorOrSystem->isDistributedActor()) {
+    auto systemTy = getConcreteReplacementForProtocolActorSystemType(actorOrSystem);
+    fprintf(stderr, "[%s:%d] (%s) systemTy\n", __FILE__, __LINE__, __FUNCTION__);
+    systemTy.dump();
+
+    system = systemTy->getNominalOrBoundGenericNominal();
+    system->dump();
+//    auto var = actorOrSystem->getDistributedActorSystemProperty();
+//    system = var->getInterfaceType()->getAnyNominal();
+  }
+
+  if (!system)
+    system = getProtocol(KnownProtocolKind::DistributedActorSystem);
+
+  auto mutableSystem = const_cast<NominalTypeDecl *>(system);
+  return evaluateOrDefault(
+      system->getASTContext().evaluator,
+      GetDistributedActorSystemRemoteCallFunctionRequest{mutableSystem, /*isVoidReturn=*/isVoidReturn},
+      nullptr);
+}
+
 /******************************************************************************/
 /********************** Distributed Actor Properties **************************/
 /******************************************************************************/

lib/SILGen/SILGenDistributed.cpp

@@ -70,6 +70,7 @@ static SILValue emitActorPropertyOrWitnessReference(
     SILLocation loc, SILValue base,
     NominalTypeDecl *selfTyDecl,
     SILType propertyType, Identifier identifier) {
+  fprintf(stderr, "[%s:%d] (%s) emitActorPropertyOrWitnessReference !!!\n", __FILE__, __LINE__, __FUNCTION__);
   /// If we're a class, just get the local property VarDecl and refer to it
   if (auto clazz = dyn_cast<ClassDecl>(selfTyDecl)) {
     return emitActorPropertyReference(
@@ -127,9 +128,8 @@ static SILValue emitActorPropertyOrWitnessReference(
 
     // === Make a reference to the getter
     // --- buffer for the system to be stored
-    Optional<SILValue> temporaryResultBuffer;
     auto buf = B.createAllocStack(loc, propertyType, None);
-    temporaryResultBuffer = SILValue(buf);
+    SILValue temporaryResultBuffer = SILValue(buf);
 
     //   %5 = witness_method $Self, #DistributedActor.actorSystem!getter : <Self where Self : DistributedActor> (Self) -> () -> Self.ActorSystem : $@convention(witness_method: DistributedActor) <τ_0_0 where τ_0_0 : DistributedActor> (@in_guaranteed τ_0_0) -> @out τ_0_0.ActorSystem
     auto witnessMethod = B.createWitnessMethod(
@@ -163,27 +163,35 @@ static SILValue emitActorPropertyOrWitnessReference(
       subs = SubstitutionMap::get(genericSig, subTypes, subConformances);
     }
 
-    SmallVector<SILValue, 2> allArgs;
-    if (temporaryResultBuffer.hasValue()) {
-      allArgs.push_back(temporaryResultBuffer.getValue());
-    }
-    allArgs.push_back(base); // self
+    SmallVector<SILValue, 2> allArgs = {
+      temporaryResultBuffer, // buffer for the property to be read into
+      base, // self
+    };
 
     // --- Apply the getter
     //   %6 = apply %5<Self>(%4, %2) : $@convention(witness_method: DistributedActor) <τ_0_0 where τ_0_0 : DistributedActor> (@in_guaranteed τ_0_0) -> @out τ_0_0.ActorSystem
     auto apply = B.createApply( loc, witnessMethod, subs, allArgs);
     apply->dump();
 
+
+
+    auto loadedProperty = B.emitLoadValueOperation(loc, temporaryResultBuffer, LoadOwnershipQualifier::Take);
+    fprintf(stderr, "[%s:%d] (%s) THE LOAD TAKE\n", __FILE__, __LINE__, __FUNCTION__);
+    loadedProperty->dump();
+
+//    SGF.enterDestroyCleanup(loadedProperty);
+    SGF.enterDeallocStackCleanup(temporaryResultBuffer);
+
     // --- Cleanup base buffer
-    if (temporaryResultBuffer) {
-      auto value = B.emitLoadValueOperation(
-          loc, *temporaryResultBuffer, LoadOwnershipQualifier::Take);
-      B.emitDestroyValueOperation(loc, value);
-      B.createDeallocStack(loc, *temporaryResultBuffer);
-    }
+//    if (temporaryResultBuffer) {
+//      auto value = B.emitLoadValueOperation(
+//          loc, *temporaryResultBuffer, LoadOwnershipQualifier::Take);
+//      B.emitDestroyValueOperation(loc, value);
+//      B.createDeallocStack(loc, *temporaryResultBuffer);
+//    }
 
     // %7 = load [trivial] %4 : $*SYSTEM_IMPL
-    return B.emitLoadValueOperation(loc, *temporaryResultBuffer, LoadOwnershipQualifier::Take);
+    return loadedProperty;
   }
 
   llvm_unreachable("Unsupported self type decl!");
@@ -956,29 +964,31 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
       //     %4 = alloc_stack $SYSTEM_IMPL                   // users: %9, %7, %6
       //     %5 = witness_method $Self, #DistributedActor.actorSystem!getter : <Self where Self : DistributedActor> (Self) -> () -> Self.ActorSystem : $@convention(witness_method: DistributedActor) <τ_0_0 where τ_0_0 : DistributedActor> (@in_guaranteed τ_0_0) -> @out τ_0_0.ActorSystem // user: %6
       //     %6 = apply %5<Self>(%4, %2) : $@convention(witness_method: DistributedActor) <τ_0_0 where τ_0_0 : DistributedActor> (@in_guaranteed τ_0_0) -> @out τ_0_0.ActorSystem
+      fprintf(stderr, "[%s:%d] (%s) GET PROP FOR MAKE INVOCATIOn\n", __FILE__, __LINE__, __FUNCTION__);
       auto systemRef = emitActorPropertyOrWitnessReference(
           *this, B, loc,
           selfValue.getValue(), selfTyDecl,
           systemSILTy, ctx.Id_actorSystem);
       assert(systemRef && "Could not find actorSystem property or requirement");
-
+      fprintf(stderr, "[%s:%d] (%s) SYSTEM REF\n", __FILE__, __LINE__, __FUNCTION__);
+      systemRef->dump();
       auto actorSystemTy = systemRef->getType();
 
       // FIXME: this is wrong for struct with values, and classes?
       // %17 = load %16 : $*FakeActorSystem // users: %21, %20, %18
-      SILValue systemLoaded;
-      if (actorSystemTy.isAddressOnly(F)) {
-        assert(false && "isAddressOnly");
-      } else {
-        if (actorSystemTy.isAddress()) {
-          systemLoaded = B.createTrivialLoadOr(
-              loc, systemRef, LoadOwnershipQualifier::Copy);
-        } else {
-          systemLoaded = B.emitCopyValueOperation(loc, systemRef);
-//          actorSystemTy.dump();
-//          llvm_unreachable("Cannot support non address actor system here?");
-        }
-      }
+//      SILValue systemLoaded;
+//      if (actorSystemTy.isAddressOnly(F)) {
+//        assert(false && "isAddressOnly");
+//      } else {
+//        if (actorSystemTy.isAddress()) {
+//          systemLoaded = B.createTrivialLoadOr(
+//              loc, systemRef, LoadOwnershipQualifier::Copy);
+//        } else {
+//          systemLoaded = B.emitCopyValueOperation(loc, systemRef);
+////          actorSystemTy.dump();
+////          llvm_unreachable("Cannot support non address actor system here?");
+//        }
+//      }
 
       // function_ref FakeActorSystem.makeInvocationEncoder()
       // %19 = function_ref @$s27FakeDistributedActorSystems0aC6SystemV21makeInvocationEncoderAA0aG0VyF : $@convention(method) (@guaranteed FakeActorSystem) -> FakeInvocation // user: %20
@@ -991,11 +1001,18 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
       ApplyInst *invocationEncoderValue = B.createApply(
           loc, makeInvocationEncoderFn,
           /*subs=*/SubstitutionMap(),
-          /*args=*/{systemLoaded});
+//          /*args=*/{systemLoaded});
+          /*args=*/{systemRef});
+
+//      if (!systemLoaded->getType().isTrivial(F) ||
+//          ((!actorSystemTy.isAddressOnly(F)) && (!actorSystemTy.isAddress()))) {
+//        fprintf(stderr, "[%s:%d] (%s) DESTROY\n", __FILE__, __LINE__, __FUNCTION__);
+//        B.createDestroyValue(loc, systemLoaded);
+//        // B.createEndLifetime(loc, systemLoaded);
+//      }
 
-      if (!systemLoaded->getType().isTrivial(F))
-        B.createDestroyValue(loc, systemLoaded);
-        // B.createEndLifetime(loc, systemLoaded);
+      B.emitDestroyValueOperation(loc, systemRef);
+//      B.createDeallocStack(loc, systemRef);
 
       // FIXME(distributed): cannot deal with class yet
       // TODO(distributed): make into "emit apropriate store"
@@ -1529,12 +1546,12 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
 //      auto systemRef = emitActorPropertyReference(
 //          *this, loc, selfValue.getValue(),
 //          lookupProperty(selfTyDecl, ctx.Id_actorSystem));
+      fprintf(stderr, "[%s:%d] (%s) GET PROP FOR REMOTE CALL\n", __FILE__, __LINE__, __FUNCTION__);
       systemRef = emitActorPropertyOrWitnessReference(
           *this, B, loc,
           selfValue.getValue(), selfTyDecl,
           systemSILTy, ctx.Id_actorSystem);
       assert(systemRef);
-      F.dump();
 //      remoteCallSystemSelf = B.createTrivialLoadOr(loc, systemRef, LoadOwnershipQualifier::Copy);
 
       // --- Prepare 'throwing' type, Error or Never depending on throws of the target
@@ -1672,6 +1689,7 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
 //        B.createDestroyValue(loc, remoteCallSystemSelf);
 //      if (remoteCallSystemSelf->getType().isAddress())
 //        B.createEndLifetime(loc, remoteCallSystemSelf);
+      B.emitDestroyValueOperation(loc, systemRef);
 
       B.createEndAccess(loc, invocationEncoderAccess, /*aborted=*/false);
       Cleanups.emitCleanupsForReturn(CleanupLocation(loc), NotForUnwind);
@@ -1695,6 +1713,7 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
 //        B.createDestroyValue(loc, remoteCallSystemSelf);
 //      if (remoteCallSystemSelf->getType().isAddress())
 //        B.createEndLifetime(loc, remoteCallSystemSelf);
+      B.emitDestroyValueOperation(loc, systemRef);
 
       Cleanups.emitCleanupsForReturn(CleanupLocation(loc), IsForUnwind);
 

lib/SILGen/SILGenFunction.cpp

@@ -522,6 +522,7 @@ void SILGenFunction::emitFunction(FuncDecl *fd) {
              fd->getResultInterfaceType(), fd->hasThrows(), fd->getThrowsLoc());
 
   if (fd->isDistributedActorFactory()) {
+    // TODO(distributed): generalize as "emit body synthesized in SIL" marker
     // Synthesize the factory function body
     emitDistributedActorFactory(fd);
   } else {

lib/SILOptimizer/Mandatory/LowerHopToActor.cpp

@@ -145,9 +145,29 @@ static bool isDefaultActorType(CanType actorType, ModuleDecl *M,
   return false;
 }
 
-static bool isDefaultDistributedActorType(CanType actorType) {
-  if (auto cls = actorType.getClassOrBoundGenericClass())
-    return cls->isDistributedActor();
+static bool isDefaultDistributedActorType(CanType actorType, SILFunction *F) {
+  auto *DC = F->getDeclContext();
+
+  if (auto classDecl = dyn_cast<ClassDecl>(DC)) {
+    return classDecl->isDistributedActor();
+  }
+
+  auto selfTy = F->getSelfArgument()->getDecl()->getInterfaceType();
+  if (auto archetype = dyn_cast<PrimaryArchetypeType>(actorType)) {
+    GenericSignature signature = DC->getGenericSignatureOfContext();
+    for (auto req : signature.getRequirements()) {
+      if (req.getFirstType()->isEqual(selfTy)) {
+        // It is a Self requirement on the actor where decl,
+        // check if it requires tha it is a distributed actor:
+        if (auto proto = req.getProtocolDecl()) {
+          if (proto->inheritsFromDistributedActor()) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+
   return false;
 }
 
@@ -184,8 +204,9 @@ SILValue LowerHopToActor::emitGetExecutor(SILLocation loc, SILValue actor,
   // If the actor type is a default actor, go ahead and devirtualize here.
   auto module = F->getModule().getSwiftModule();
   SILValue unmarkedExecutor;
+  fprintf(stderr, "[%s:%d] (%s) isDefaultDistributedActorType(actorType) = %d\n", __FILE__, __LINE__, __FUNCTION__, isDefaultDistributedActorType(actorType, F));
   if (isDefaultActorType(actorType, module, F->getResilienceExpansion()) ||
-      isDefaultDistributedActorType(actorType)) {
+      isDefaultDistributedActorType(actorType, F)) {
     auto builtinName = ctx.getIdentifier(
       getBuiltinName(BuiltinValueKind::BuildDefaultActorExecutorRef));
     auto builtinDecl = cast<FuncDecl>(getBuiltinValueDecl(ctx, builtinName));

lib/SILOptimizer/Utils/DistributedActor.cpp

@@ -65,7 +65,7 @@ void emitDistributedActorSystemWitnessCall(
   auto &C = F.getASTContext();
 
   // Dig out the conformance to DistributedActorSystem.
-  ProtocolDecl *DAS = C.getDistributedActorDecl();
+  ProtocolDecl *DAS = C.getDistributedActorSystemDecl();
   assert(DAS);
   auto systemASTType = base->getType().getASTType();
   auto *module = M.getSwiftModule();
@@ -81,6 +81,8 @@ void emitDistributedActorSystemWitnessCall(
         OpenedExistentialAccess::Immutable);
   }
 
+  fprintf(stderr, "[%s:%d] (%s) systemASTType\n", __FILE__, __LINE__, __FUNCTION__);
+  systemASTType.dump();
   if (systemASTType->isTypeParameter() || systemASTType->is<ArchetypeType>()) {
     systemConfRef = ProtocolConformanceRef(DAS);
   } else {