[Concurrency] unownedExecutor can be declared not directly on actor

Author: ktoso

lib/AST/Decl.cpp

@@ -9356,38 +9356,27 @@ Type TypeBase::getSwiftNewtypeUnderlyingType() {
 }
 
 const VarDecl *ClassDecl::getUnownedExecutorProperty() const {
-  auto &ctx = getASTContext();
+  auto &C = getASTContext();
+  auto module = getParentModule();
 
-  auto hasUnownedSerialExecutorType = [&](VarDecl *property) {
-    if (auto type = property->getInterfaceType())
-      if (auto td = type->getAnyNominal())
-        if (td == ctx.getUnownedSerialExecutorDecl())
-          return true;
-    return false;
-  };
+  if (!isAnyActor())
+    return nullptr;
 
-  VarDecl *candidate = nullptr;
-  for (auto member: getMembers()) {
-    // Instance properties called unownedExecutor.
-    if (auto property = dyn_cast<VarDecl>(member)) {
-      if (property->getName() == ctx.Id_unownedExecutor &&
-          !property->isStatic()) {
-        if (!candidate) {
-          candidate = property;
-          continue;
-        }
+  llvm::SmallVector<ValueDecl *, 2> results;
+  this->lookupQualified(getSelfNominalTypeDecl(),
+                        DeclNameRef(C.Id_unownedExecutor),
+                        NL_ProtocolMembers,
+                        results);
 
-        bool oldHasRightType = hasUnownedSerialExecutorType(candidate);
-        if (oldHasRightType == hasUnownedSerialExecutorType(property)) {
-          // just ignore the new property, we should diagnose this eventually
-        } else if (!oldHasRightType) {
-          candidate = property;
-        }
-      }
-    }
+  for (auto candidate: results) {
+    if (isa<ProtocolDecl>(candidate->getDeclContext()))
+      continue;
+
+    if (VarDecl *var = dyn_cast<VarDecl>(candidate))
+      return var;
   }
 
-  return candidate;
+  return nullptr;
 }
 
 bool ClassDecl::isRootDefaultActor() const {

stdlib/public/Concurrency/GlobalExecutor.cpp

@@ -125,6 +125,10 @@ void swift::swift_task_enqueueGlobalWithDeadline(
     swift_task_enqueueGlobalWithDeadlineImpl(sec, nsec, tsec, tnsec, clock, job);
 }
 
+/*****************************************************************************/
+/****************************** MAIN EXECUTOR  *******************************/
+/*****************************************************************************/
+
 void swift::swift_task_enqueueMainExecutor(Job *job) {
   concurrency::trace::job_enqueue_main_executor(job);
   if (swift_task_enqueueMainExecutor_hook)

test/Concurrency/Runtime/custom_executors_default.swift

@@ -0,0 +1,50 @@
+// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking %import-libdispatch -parse-as-library) | %FileCheck %s
+
+// REQUIRES: concurrency
+// REQUIRES: executable_test
+// UNSUPPORTED: freestanding
+
+// UNSUPPORTED: back_deployment_runtime
+// REQUIRES: concurrency_runtime
+
+
+actor Simple {
+  var count = 0
+  func report() {
+    print("simple.count == \(count)")
+    count += 1
+  }
+}
+
+actor Custom {
+  var count = 0
+  let simple = Simple()
+
+  func report() async {
+    print("custom.count == \(count)")
+    count += 1
+
+    await simple.report()
+  }
+}
+
+@available(SwiftStdlib 5.1, *)
+@main struct Main {
+  static func main() async {
+    print("begin")
+    let actor = Custom()
+    await actor.report()
+    await actor.report()
+    await actor.report()
+    print("end")
+  }
+}
+
+// CHECK:      begin
+// CHECK-NEXT: custom.count == 0
+// CHECK-NEXT: simple.count == 0
+// CHECK-NEXT: custom.count == 1
+// CHECK-NEXT: simple.count == 1
+// CHECK-NEXT: custom.count == 2
+// CHECK-NEXT: simple.count == 2
+// CHECK-NEXT: end

test/Concurrency/Runtime/custom_executors_protocol.swift

@@ -0,0 +1,89 @@
+// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking %import-libdispatch -parse-as-library) | %FileCheck %s
+
+// REQUIRES: concurrency
+// REQUIRES: executable_test
+// REQUIRES: libdispatch
+// UNSUPPORTED: freestanding
+
+// UNSUPPORTED: back_deployment_runtime
+// REQUIRES: concurrency_runtime
+
+import Dispatch
+
+func checkIfMainQueue(expectedAnswer expected: Bool) {
+  dispatchPrecondition(condition: expected ? .onQueue(DispatchQueue.main)
+      : .notOnQueue(DispatchQueue.main))
+}
+
+protocol WithSpecifiedExecutor: Actor {
+  nonisolated var executor: SpecifiedExecutor { get }
+}
+
+protocol SpecifiedExecutor: SerialExecutor {}
+
+extension WithSpecifiedExecutor {
+  /// Establishes the WithSpecifiedExecutorExecutor as the serial
+  /// executor that will coordinate execution for the actor.
+  nonisolated var unownedExecutor: UnownedSerialExecutor {
+    executor.asUnownedSerialExecutor()
+  }
+}
+
+final class InlineExecutor: SpecifiedExecutor, Swift.CustomStringConvertible {
+  let name: String
+
+  init(_ name: String) {
+    self.name = name
+  }
+
+  public func enqueue(_ job: UnownedJob) {
+    print("\(self): enqueue")
+    job._runSynchronously(on: self.asUnownedSerialExecutor())
+    print("\(self): after run")
+  }
+
+  public func asUnownedSerialExecutor() -> UnownedSerialExecutor {
+    return UnownedSerialExecutor(ordinary: self)
+  }
+
+  var description: Swift.String {
+    "InlineExecutor(\(name))"
+  }
+}
+
+actor MyActor: WithSpecifiedExecutor {
+
+  nonisolated let executor: SpecifiedExecutor
+
+  // Note that we don't have to provide the unownedExecutor in the actor itself.
+  // We obtain it from the extension on `WithSpecifiedExecutor`.
+
+  init(executor: SpecifiedExecutor) {
+    self.executor = executor
+  }
+
+  func test(expectedExecutor: some SerialExecutor) {
+    checkIfMainQueue(expectedAnswer: true)
+    print("\(Self.self): on executor \(expectedExecutor)")
+  }
+}
+
+@main struct Main {
+  static func main() async {
+    print("begin")
+    let one = InlineExecutor("one")
+    let actor = MyActor(executor: one)
+    await actor.test(expectedExecutor: one)
+    await actor.test(expectedExecutor: one)
+    await actor.test(expectedExecutor: one)
+    print("end")
+  }
+}
+
+// CHECK:      begin
+// CHECK-NEXT: InlineExecutor(one): enqueue
+// CHECK-NEXT: MyActor: on executor InlineExecutor(one)
+// CHECK-NEXT: MyActor: on executor InlineExecutor(one)
+// CHECK-NEXT: MyActor: on executor InlineExecutor(one)
+// CHECK-NEXT: InlineExecutor(one): after run
+// CHECK-NEXT: end