[Concurrency] Distributed actor's unownedExecutor should be optional

Author: ktoso

include/swift/AST/KnownIdentifiers.def

@@ -231,6 +231,7 @@ IDENTIFIER(className)
 IDENTIFIER(_defaultActorInitialize)
 IDENTIFIER(_defaultActorDestroy)
 IDENTIFIER(unownedExecutor)
+IDENTIFIER(localUnownedExecutor)
 
 IDENTIFIER_(ErrorType)
 IDENTIFIER(Code)

include/swift/AST/KnownSDKDecls.def

@@ -20,6 +20,7 @@
 #endif
 
 KNOWN_SDK_FUNC_DECL(Distributed, IsRemoteDistributedActor, "__isRemoteActor")
+KNOWN_SDK_FUNC_DECL(Distributed, IsLocalDistributedActor, "__isLocalActor")
 
 #undef KNOWN_SDK_FUNC_DECL
 

lib/SILOptimizer/Mandatory/LowerHopToActor.cpp

@@ -186,7 +186,7 @@ SILValue LowerHopToActor::emitGetExecutor(SILBuilderWithScope &B,
     unmarkedExecutor =
       B.createBuiltin(loc, builtinName, resultType, subs, {actor});
 
-  // Otherwise, go through Actor.unownedExecutor.
+  // Otherwise, go through (Distributed)Actor.unownedExecutor.
   } else {
     auto actorKind = actorType->isDistributedActor() ?
                      KnownProtocolKind::DistributedActor :
@@ -214,6 +214,8 @@ SILValue LowerHopToActor::emitGetExecutor(SILBuilderWithScope &B,
     auto executorDecl = ctx.getUnownedSerialExecutorDecl();
     auto executorProps = executorDecl->getStoredProperties();
     assert(executorProps.size() == 1);
+    fprintf(stderr, "[%s:%d](%s) executorProps = \n", __FILE_NAME__, __LINE__, __FUNCTION__);
+    executorProps[0]->dump();
     unmarkedExecutor =
       B.createStructExtract(loc, witnessCall, executorProps[0]);
   }

lib/Sema/DerivedConformanceDistributedActor.cpp

@@ -620,9 +620,79 @@ static Expr *constructDistributedUnownedSerialExecutor(ASTContext &ctx,
   return nullptr;
 }
 
+//static Expr *constructOptionalSome(ASTContext &ctx,
+//                                   Expr *arg) {
+//  auto optionalDecl = ctx.getOptionalDecl();
+//  if (!optionalDecl) return nullptr;
+//
+//  for (auto member: optionalDecl->getAllMembers()) {
+//    auto ctor = dyn_cast<ConstructorDecl>(member);
+//    if (!ctor) continue;
+//
+//    // Find the init(_:) which initialized as `some`
+//    auto params = ctor->getParameters();
+//    if (params->size() != 1 ||
+//        params->get(0)->getArgumentName() != Identifier())
+//      continue;
+//
+//    ctor->dump();
+//
+//
+////    Type optionalType = optionalDecl->getDeclaredInterfaceType();
+////    fprintf(stderr, "[%s:%d](%s) optionalDecl\n", __FILE_NAME__, __LINE__, __FUNCTION__);
+////    optionalType.dump();
+//
+//    Type optionalType = BoundGenericEnumType::get(optionalDecl, Type(), {arg->getType()});
+//    fprintf(stderr, "[%s:%d](%s) better optionalType\n", __FILE_NAME__, __LINE__, __FUNCTION__);
+//    optionalType->dump();
+//
+//    Type ctorType = ctor->getInterfaceType();
+//    fprintf(stderr, "[%s:%d](%s) ctor type\n", __FILE_NAME__, __LINE__, __FUNCTION__);
+//    ctorType->dump();
+//
+//    // We have the right initializer. Build a reference to it of type:
+//    //   (Optional.Type)
+//    //      -> (T) -> T
+//    auto initRef = new (ctx) DeclRefExpr(ctor, DeclNameLoc(), /*implicit*/true,
+//                                         AccessSemantics::Ordinary,
+//                                         ctorType);
+//
+//    // Apply the initializer to the metatype, building an expression of type:
+//    //   (Builtin.Executor) -> Optional<UnownedSerialExecutor>
+//    // auto metatypeRef = TypeExpr::createImplicit(optionalType, ctx);
+//    auto metatypeRef = TypeExpr::createImplicit(optionalType, ctx);
+//    GenericIdentTypeRepr::create(ctx, DeclNameLoc(optionalDecl->getNameLoc()),
+//                                 DeclNameRef(optionalDecl->getBaseName()),
+//                                 {arg->getType()}, SourceRange());
+////
+////    auto ctorAppliedType = new (ctx) TypeRepr(
+////        GenericIdentTypeRepr::create(ctx, DeclNameLoc(), )
+////        );
+//
+////    TypeExpr::createForSpecializedDecl(optionalType.get, {arg->getType()}, SourceRange(), ctx);
+////    Type ctorAppliedType = ctorType->getAs<FunctionType>()->getResult();
+//    auto selfApply = ConstructorRefCallExpr::create(ctx, initRef, metatypeRef
+////                                                    ,
+////                                                    ctorAppliedType
+//                                                    );
+//    selfApply->setImplicit(true);
+//    selfApply->setThrows(false);
+//
+//    // Call the constructor, building an expression of type
+//    // Optional<T>.
+//    auto *argList = ArgumentList::forImplicitUnlabeled(ctx, {arg});
+//    auto call = CallExpr::createImplicit(ctx, selfApply, argList);
+//    call->setType(optionalType);
+//    call->setThrows(false);
+//    return call;
+//  }
+//
+//  assert(false);
+//}
+
 static std::pair<BraceStmt *, bool>
 deriveBodyDistributedActor_unownedExecutor(AbstractFunctionDecl *getter, void *) {
-  // var unownedExecutor: UnownedSerialExecutor {
+  // var unownedExecutor: UnownedSerialExecutor? {
   //   get {
   //     return Builtin.buildDefaultActorExecutorRef(self)
   //   }
@@ -641,33 +711,58 @@ deriveBodyDistributedActor_unownedExecutor(AbstractFunctionDecl *getter, void *)
   Expr *selfArg = DerivedConformance::createSelfDeclRef(getter);
   selfArg->setType(selfType);
 
+  // Prepare the builtin call, we'll use it after the guard, but want to take the type
+  // of its return type earlier, so we prepare it here.
+
   // The builtin call gives us a Builtin.Executor.
   auto builtinCall =
       DerivedConformance::createBuiltinCall(ctx,
                                             BuiltinValueKind::BuildDefaultActorExecutorRef,
                                             {selfType}, {}, {selfArg});
-
   // Turn that into an UnownedSerialExecutor.
   auto initCall = constructDistributedUnownedSerialExecutor(ctx, builtinCall);
   if (!initCall) return failure();
 
-  auto ret = new (ctx) ReturnStmt(SourceLoc(), initCall, /*implicit*/ true);
+  // guard __isLocalActor(self) else {
+  //   return nil
+  // }
+  auto isLocalActorDecl = ctx.getIsLocalDistributedActor();
+  DeclRefExpr *isLocalActorExpr =
+      new (ctx) DeclRefExpr(ConcreteDeclRef(isLocalActorDecl), DeclNameLoc(), /*implicit=*/true,
+                            AccessSemantics::Ordinary,
+                            FunctionType::get({AnyFunctionType::Param(ctx.getAnyObjectType())},
+                                              ctx.getBoolType()));
+  Expr *selfForIsLocalArg = DerivedConformance::createSelfDeclRef(getter);
+  selfForIsLocalArg->setType(selfType);
+  auto *argListForIsLocal =
+      ArgumentList::forImplicitSingle(ctx, Identifier(),
+                                      ErasureExpr::create(ctx, selfForIsLocalArg, ctx.getAnyObjectType(), {}, {}));
+  CallExpr *isLocalActorCall = CallExpr::createImplicit(ctx, isLocalActorExpr, argListForIsLocal);
+  isLocalActorCall->setType(ctx.getBoolType());
+  isLocalActorCall->setThrows(false);
+  auto returnNilIfRemoteStmt = DerivedConformance::returnNilIfFalseGuardTypeChecked(
+      ctx, isLocalActorCall, /*optionalWrappedType=*/initCall->getType());
+
+
+  // Finalize preparing the unowned executor for returning.
+  auto wrappedCall = new (ctx) InjectIntoOptionalExpr(initCall, initCall->getType()->wrapInOptionalType());
+
+  auto ret = new (ctx) ReturnStmt(SourceLoc(), wrappedCall, /*implicit*/ true);
 
   auto body = BraceStmt::create(
-      ctx, SourceLoc(), { ret }, SourceLoc(), /*implicit=*/true);
+      ctx, SourceLoc(), { returnNilIfRemoteStmt, ret }, SourceLoc(), /*implicit=*/true);
+
+  fprintf(stderr, "[%s:%d](%s) ================================================================================================\n", __FILE_NAME__, __LINE__, __FUNCTION__);
+  body->dump();
+  fprintf(stderr, "[%s:%d](%s) ================================================================================================\n", __FILE_NAME__, __LINE__, __FUNCTION__);
+
   return { body, /*isTypeChecked=*/true };
 }
 
 /// Derive the declaration of DistributedActor's unownedExecutor property.
 static ValueDecl *deriveDistributedActor_unownedExecutor(DerivedConformance &derived) {
   ASTContext &ctx = derived.Context;
 
-  if (auto classDecl = dyn_cast<ClassDecl>(derived.Nominal)) {
-    if (auto existing = classDecl->getUnownedExecutorProperty()) {
-      return const_cast<VarDecl*>(existing);
-    }
-  }
-
   // Retrieve the types and declarations we'll need to form this operation.
   auto executorDecl = ctx.getUnownedSerialExecutorDecl();
   if (!executorDecl) {
@@ -676,16 +771,28 @@ static ValueDecl *deriveDistributedActor_unownedExecutor(DerivedConformance &der
     return nullptr;
   }
   Type executorType = executorDecl->getDeclaredInterfaceType();
+  Type optionalExecutorType = executorType->wrapInOptionalType();
+
+  if (auto classDecl = dyn_cast<ClassDecl>(derived.Nominal)) {
+    if (auto existing = classDecl->getUnownedExecutorProperty()) {
+      if (existing->getInterfaceType()->isEqual(optionalExecutorType)) {
+        return const_cast<VarDecl *>(existing);
+      } else {
+        // bad type, should be diagnosed elsewhere
+        return nullptr;
+      }
+    }
+  }
 
   auto propertyPair = derived.declareDerivedProperty(
       DerivedConformance::SynthesizedIntroducer::Var, ctx.Id_unownedExecutor,
-      executorType, executorType,
+      optionalExecutorType, optionalExecutorType,
       /*static*/ false, /*final*/ false);
   auto property = propertyPair.first;
   property->setSynthesized(true);
   property->getAttrs().add(new (ctx) SemanticsAttr(SEMANTICS_DEFAULT_ACTOR,
                                                    SourceLoc(), SourceRange(),
-      /*implicit*/ true));
+                                                   /*implicit*/ true));
   property->getAttrs().add(new (ctx) NonisolatedAttr(/*IsImplicit=*/true));
 
   // Make the property implicitly final.
@@ -703,7 +810,7 @@ static ValueDecl *deriveDistributedActor_unownedExecutor(DerivedConformance &der
       property, asAvailableAs, ctx);
 
   auto getter =
-      derived.addGetterToReadOnlyDerivedProperty(property, executorType);
+      derived.addGetterToReadOnlyDerivedProperty(property, optionalExecutorType);
   getter->setBodySynthesizer(deriveBodyDistributedActor_unownedExecutor);
 
   // IMPORTANT: MUST BE AFTER [id, actorSystem].

lib/Sema/DerivedConformances.cpp

@@ -674,6 +674,37 @@ GuardStmt *DerivedConformance::returnFalseIfNotEqualGuard(ASTContext &C,
   auto falseExpr = new (C) BooleanLiteralExpr(false, SourceLoc(), true);
   return returnIfNotEqualGuard(C, lhsExpr, rhsExpr, falseExpr);
 }
+/// Returns a generated guard statement that checks whether the given expr is true.
+/// If it is false, the else block for the guard returns `nil`.
+/// \p C The AST context.
+/// \p testExpr The expression that should be tested.
+/// \p baseType The wrapped type of the to-be-returned Optional<Wrapped>.
+GuardStmt *DerivedConformance::returnNilIfFalseGuardTypeChecked(ASTContext &C,
+                                        Expr *testExpr,
+                                        Type optionalWrappedType) {
+  auto trueExpr = new (C) BooleanLiteralExpr(true, SourceLoc(), /*implicit=*/true);
+  auto nilExpr = new (C) NilLiteralExpr(SourceLoc(), /*implicit=*/true);
+  nilExpr->setType(optionalWrappedType->wrapInOptionalType());
+
+  SmallVector<StmtConditionElement, 1> conditions;
+  SmallVector<ASTNode, 1> statements;
+
+  auto returnStmt = new (C) ReturnStmt(SourceLoc(), nilExpr);
+  statements.push_back(returnStmt);
+
+  // Next, generate the condition being checked.
+//  auto cmpFuncExpr = new (C) UnresolvedDeclRefExpr(
+//      DeclNameRef(C.Id_EqualsOperator), DeclRefKind::BinaryOperator,
+//      DeclNameLoc());
+//  auto *cmpExpr = BinaryExpr::create(C, lhsExpr, cmpFuncExpr, rhsExpr,
+//      /*implicit*/ true);
+  conditions.emplace_back(testExpr);
+
+  // Build and return the complete guard statement.
+  // guard lhs == rhs else { return lhs < rhs }
+  auto body = BraceStmt::create(C, SourceLoc(), statements, SourceLoc());
+  return new (C) GuardStmt(SourceLoc(), C.AllocateCopy(conditions), body);
+}
 /// Returns a generated guard statement that checks whether the given lhs and
 /// rhs expressions are equal. If not equal, the else block for the guard
 /// returns lhs < rhs.

lib/Sema/DerivedConformances.h

@@ -409,6 +409,12 @@ class DerivedConformance {
   // return false
   static GuardStmt *returnFalseIfNotEqualGuard(ASTContext &C, Expr *lhsExpr,
                                                Expr *rhsExpr);
+
+  // Return `nil` is the `testExp` is `false`.
+  static GuardStmt *returnNilIfFalseGuardTypeChecked(ASTContext &C,
+                                                     Expr *testExpr,
+                                                     Type optionalWrappedType);
+
   // return lhs < rhs
   static GuardStmt *
   returnComparisonIfNotEqualGuard(ASTContext &C, Expr *lhsExpr, Expr *rhsExpr);

stdlib/public/Concurrency/Executor.swift

@@ -101,7 +101,8 @@ public struct UnownedSerialExecutor: Sendable {
   @usableFromInline
   internal var executor: Builtin.Executor
 
-  @_spi(ConcurrencyExecutors)
+  /// SPI: Do not use. Cannot be marked @_spi, since we need to use it from Distributed module
+  /// which needs to reach for this from an @_transparent function which prevents @_spi use.
   @available(SwiftStdlib 5.9, *)
   public var _executor: Builtin.Executor {
     self.executor

stdlib/public/Distributed/DistributedActor.swift

@@ -254,8 +254,11 @@ public protocol DistributedActor: AnyActor, Identifiable, Hashable
   /// eliminated, and rearranged with other work, and they may even
   /// be introduced when not strictly required.  Visible side effects
   /// are therefore strongly discouraged within this property.
+//  @available(SwiftStdlib 5.9, *)
+//  nonisolated var localUnownedExecutor: UnownedSerialExecutor? { get }
+
   @available(SwiftStdlib 5.9, *)
-  nonisolated var unownedExecutor: UnownedSerialExecutor { get }
+  nonisolated var unownedExecutor: UnownedSerialExecutor? { get }
 
   /// Resolves the passed in `id` against the `system`, returning
   /// either a local or remote actor reference.