complete implementation using localUnownedExecutor customization point

Author: ktoso

include/swift/AST/Decl.h

@@ -4533,6 +4533,7 @@ class ClassDecl final : public NominalTypeDecl {
 
   /// Fetch this class's unownedExecutor property, if it has one.
   const VarDecl *getUnownedExecutorProperty() const;
+  const VarDecl *getLocalUnownedExecutorProperty() const;
 
   /// Is this the NSObject class type?
   bool isNSObject() const;

lib/AST/Decl.cpp

@@ -9625,6 +9625,29 @@ const VarDecl *ClassDecl::getUnownedExecutorProperty() const {
   return nullptr;
 }
 
+const VarDecl *ClassDecl::getLocalUnownedExecutorProperty() const {
+  auto &C = getASTContext();
+
+  if (!isDistributedActor())
+    return nullptr;
+
+  llvm::SmallVector<ValueDecl *, 2> results;
+  this->lookupQualified(getSelfNominalTypeDecl(),
+                        DeclNameRef(C.Id_localUnownedExecutor),
+                        NL_ProtocolMembers,
+                        results);
+
+  for (auto candidate: results) {
+    if (isa<ProtocolDecl>(candidate->getDeclContext()))
+      continue;
+
+    if (VarDecl *var = dyn_cast<VarDecl>(candidate))
+      return var;
+  }
+
+  return nullptr;
+}
+
 bool ClassDecl::isRootDefaultActor() const {
   return isRootDefaultActor(getModuleContext(), ResilienceExpansion::Maximal);
 }

lib/SILOptimizer/Mandatory/LowerHopToActor.cpp

@@ -192,6 +192,7 @@ SILValue LowerHopToActor::emitGetExecutor(SILBuilderWithScope &B,
                      KnownProtocolKind::DistributedActor :
                      KnownProtocolKind::Actor;
     auto actorProtocol = ctx.getProtocol(actorKind);
+    bool optionalExecutor = false;
     auto req = getUnownedExecutorGetter(ctx, actorProtocol);
     assert(req && "Concurrency library broken");
     SILDeclRef fn(req, SILDeclRef::Kind::Func);
@@ -214,8 +215,6 @@ 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,81 +620,14 @@ 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? {
+deriveBodyDistributedActor_localUnownedExecutor(AbstractFunctionDecl *getter, void *) {
+  // var localUnownedExecutor: UnownedSerialExecutor? {
   //   get {
-  //     return Builtin.buildDefaultActorExecutorRef(self)
+  //     guard __isLocalActor(self) else {
+  //       return nil
+  //     }
+  //     return Optional(Builtin.buildDefaultActorExecutorRef(self))
   //   }
   // }
   ASTContext &ctx = getter->getASTContext();
@@ -751,16 +684,11 @@ deriveBodyDistributedActor_unownedExecutor(AbstractFunctionDecl *getter, void *)
 
   auto body = BraceStmt::create(
       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) {
+/// Derive the declaration of DistributedActor's localUnownedExecutor property.
+static ValueDecl *deriveDistributedActor_localUnownedExecutor(DerivedConformance &derived) {
   ASTContext &ctx = derived.Context;
 
   // Retrieve the types and declarations we'll need to form this operation.
@@ -774,7 +702,7 @@ static ValueDecl *deriveDistributedActor_unownedExecutor(DerivedConformance &der
   Type optionalExecutorType = executorType->wrapInOptionalType();
 
   if (auto classDecl = dyn_cast<ClassDecl>(derived.Nominal)) {
-    if (auto existing = classDecl->getUnownedExecutorProperty()) {
+    if (auto existing = classDecl->getLocalUnownedExecutorProperty()) {
       if (existing->getInterfaceType()->isEqual(optionalExecutorType)) {
         return const_cast<VarDecl *>(existing);
       } else {
@@ -785,7 +713,7 @@ static ValueDecl *deriveDistributedActor_unownedExecutor(DerivedConformance &der
   }
 
   auto propertyPair = derived.declareDerivedProperty(
-      DerivedConformance::SynthesizedIntroducer::Var, ctx.Id_unownedExecutor,
+      DerivedConformance::SynthesizedIntroducer::Var, ctx.Id_localUnownedExecutor,
       optionalExecutorType, optionalExecutorType,
       /*static*/ false, /*final*/ false);
   auto property = propertyPair.first;
@@ -811,7 +739,7 @@ static ValueDecl *deriveDistributedActor_unownedExecutor(DerivedConformance &der
 
   auto getter =
       derived.addGetterToReadOnlyDerivedProperty(property, optionalExecutorType);
-  getter->setBodySynthesizer(deriveBodyDistributedActor_unownedExecutor);
+  getter->setBodySynthesizer(deriveBodyDistributedActor_localUnownedExecutor);
 
   // IMPORTANT: MUST BE AFTER [id, actorSystem].
   if (auto id = derived.Nominal->getDistributedActorIDProperty()) {
@@ -854,24 +782,24 @@ static void assertRequiredSynthesizedPropertyOrder(DerivedConformance &derived,
     if (auto id = Nominal->getDistributedActorIDProperty()) {
       if (auto system = Nominal->getDistributedActorSystemProperty()) {
         if (auto classDecl = dyn_cast<ClassDecl>(derived.Nominal)) {
-          if (auto unownedExecutor = classDecl->getUnownedExecutorProperty()) {
-            int idIdx, actorSystemIdx, unownedExecutorIdx = 0;
+          if (auto localUnownedExecutor = classDecl->getLocalUnownedExecutorProperty()) {
+            int idIdx, actorSystemIdx, localUnownedExecutorIdx = 0;
             int idx = 0;
             for (auto member: Nominal->getMembers()) {
               if (auto binding = dyn_cast<PatternBindingDecl>(member)) {
                 if (binding->getSingleVar()->getName() == Context.Id_id) {
                   idIdx = idx;
                 } else if (binding->getSingleVar()->getName() == Context.Id_actorSystem) {
                   actorSystemIdx = idx;
-                } else if (binding->getSingleVar()->getName() == Context.Id_unownedExecutor) {
-                  unownedExecutorIdx = idx;
+                } else if (binding->getSingleVar()->getName() == Context.Id_localUnownedExecutor) {
+                  localUnownedExecutorIdx = idx;
                 }
                 idx += 1;
               }
             }
-            if (idIdx + actorSystemIdx + unownedExecutorIdx >= 0 + 1 + 2) {
+            if (idIdx + actorSystemIdx + localUnownedExecutorIdx >= 0 + 1 + 2) {
               // we have found all the necessary fields, let's assert their order
-              assert(idIdx < actorSystemIdx < unownedExecutorIdx && "order of fields MUST be exact.");
+              assert(idIdx < actorSystemIdx < localUnownedExecutorIdx && "order of fields MUST be exact.");
             }
           }
         }
@@ -893,8 +821,8 @@ ValueDecl *DerivedConformance::deriveDistributedActor(ValueDecl *requirement) {
       derivedValue = deriveDistributedActor_id(*this);
     } else if (var->getName() == Context.Id_actorSystem) {
       derivedValue = deriveDistributedActor_actorSystem(*this);
-    } else if (var->getName() == Context.Id_unownedExecutor) {
-      derivedValue = deriveDistributedActor_unownedExecutor(*this);
+    } else if (var->getName() == Context.Id_localUnownedExecutor) {
+      derivedValue = deriveDistributedActor_localUnownedExecutor(*this);
     }
 
     assertRequiredSynthesizedPropertyOrder(*this, derivedValue);

lib/Sema/DerivedConformances.cpp

@@ -335,11 +335,11 @@ ValueDecl *DerivedConformance::getDerivableRequirement(NominalTypeDecl *nominal,
 
     // Actor.unownedExecutor
     if (name.isSimpleName(ctx.Id_unownedExecutor)) {
-      if (nominal->isDistributedActor()) {
-        return getRequirement(KnownProtocolKind::DistributedActor);
-      } else {
+//      if (nominal->isDistributedActor()) {
+//        return getRequirement(KnownProtocolKind::DistributedActor);
+//      } else {
         return getRequirement(KnownProtocolKind::Actor);
-      }
+//      }
     }
 
     // DistributedActor.id
@@ -350,6 +350,11 @@ ValueDecl *DerivedConformance::getDerivableRequirement(NominalTypeDecl *nominal,
     if (name.isSimpleName(ctx.Id_actorSystem))
       return getRequirement(KnownProtocolKind::DistributedActor);
 
+    // DistributedActor.localUnownedExecutor
+    if (name.isSimpleName(ctx.Id_localUnownedExecutor)) {
+      return getRequirement(KnownProtocolKind::DistributedActor);
+    }
+
     return nullptr;
   }
 
@@ -682,7 +687,6 @@ GuardStmt *DerivedConformance::returnFalseIfNotEqualGuard(ASTContext &C,
 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());
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -192,19 +192,39 @@ bool IsDefaultActorRequest::evaluate(
   // If we synthesized the unownedExecutor property, we should've
   // added a semantics attribute to it (if it was actually a default
   // actor).
+  bool foundExecutorPropertyImpl = false;
+  bool isDefaultActor = false;
   if (auto executorProperty = classDecl->getUnownedExecutorProperty()) {
-    bool isDefaultActor =
+    foundExecutorPropertyImpl = true;
+    isDefaultActor = isDefaultActor ||
         executorProperty->getAttrs().hasSemanticsAttr(SEMANTICS_DEFAULT_ACTOR);
+  }
+
+  // Maybe it was a distributed actor, let's double-check it's localUnownedExecutor property.
+  // If we synthesized that one with appropriate semantics we may still be a default actor.
+  if (!isDefaultActor && classDecl->isDistributedActor()) {
+    if (auto localExecutorProperty = classDecl->getLocalUnownedExecutorProperty()) {
+      foundExecutorPropertyImpl = true;
+      isDefaultActor = isDefaultActor ||
+          localExecutorProperty->getAttrs().hasSemanticsAttr(SEMANTICS_DEFAULT_ACTOR);
+    }
+  }
+
+  // Only if we found one of the executor properties, do we return the status of default or not,
+  // based on the findings of the semantics attribute of that located property.
+  if (foundExecutorPropertyImpl) {
     if (!isDefaultActor &&
         classDecl->getASTContext().LangOpts.isConcurrencyModelTaskToThread() &&
         !AvailableAttr::isUnavailable(classDecl)) {
       classDecl->diagnose(
           diag::concurrency_task_to_thread_model_custom_executor,
           "task-to-thread concurrency model");
     }
+
     return isDefaultActor;
   }
 
+  // Otherwise, we definitely are a default actor.
   return true;
 }
 

lib/Sema/TypeCheckDeclOverride.cpp

@@ -2039,8 +2039,8 @@ static bool checkSingleOverride(ValueDecl *override, ValueDecl *base) {
               cast<ClassDecl>(prop->getDeclContext())->isActor() &&
               !prop->isStatic() &&
               prop->getName() == ctx.Id_unownedExecutor &&
-              prop->getInterfaceType()->getAnyNominal() ==
-                ctx.getUnownedSerialExecutorDecl());
+              prop->getName() == ctx.Id_localUnownedExecutor &&
+              prop->getInterfaceType()->getAnyNominal() == ctx.getUnownedSerialExecutorDecl());
     };
 
     if (isActorUnownedExecutor()) {

stdlib/public/Concurrency/Executor.swift

@@ -110,7 +110,8 @@ public struct UnownedSerialExecutor: Sendable {
   #endif
 
   @inlinable
-  internal init(_ executor: Builtin.Executor) {
+  // @_spi(ConcurrencyExecutors) // FIXME:!!!!
+  public init(_ executor: Builtin.Executor) {
     #if compiler(>=5.5) && $BuiltinExecutor
     self.executor = executor
     #endif