Concurrency runtime never calls swift_task_enqueueMainExecutor_hook

[MarSe32m]

Description
The hook swift_task_enqueueMainExecutor_hook is exported for users to implement custom main executor behavior but the concurrency runtime never calls this hook even though someone assigns a closure to it. On the other hand swift_task_enqueueGlobal_hook works as expected.

Steps to reproduce

swift_task_enqueueGlobal_hook = { job, original in 
    print("enqueueGlobal")
    original(job)
}

swift_task_enqueueMainExecutor_hook = { job, original in
    print("enqueueMainExecutor")
    original(job)
}

@MainActor
func someMainActorFunc() async {
    print("Main actor function")
}

Task { @MainActor in 
    print("Main actor task 1")
}

Task.detached { @MainActor in
    print("Main actor task 2")
}

Task.detached {
    print("Non main actor task")
}

await Task.detached {
    await someMainActorFunc()
}.value

To reproduce clone the package and swift run.

Expected behavior
It is expected that enqueueMainExecutor would be printed a couple of times.

Actual behavior
The output doesn't have any enqueueMainExecutors printed. The actual output is of the form:

enqueueGlobal
enqueueGlobal
enqueueGlobal
enqueueGlobal
Non main actor task
Main actor task 1
Main actor task 2
Main actor function
enqueueGlobal

Environment

• Swift compiler version info: from 5.5 to 5.7.3 to nightly January 18, 2023
• Platforms: macOS, Windows, Linux

[MarSe32m]

Related forum thread.

[ephemer]

Your reply in the forum thread is important here. In particular the realisation that the current implementation of MainActor calls

func enqueue(_ job: UnownedJob) {
     _enqueueOnDispatchQueue(job, queue: self) 
}

(which doesn't provide any runtime hook), instead of:

public nonisolated func enqueue(_ job: UnownedJob) {
    _enqueueOnMain(job)
}

which appears to be what swift_task_enqueueMainExecutor_hook was implemented for initially.

One workaround would be to avoid the combination of swift_task_enqueueMainExecutor_hook with the DispatchGlobalExecutor and use the NonDispatchGlobalExecutor instead. We may indeed want to do that eventually (e.g. on Android), but for now it'd be helpful to only override MainActor invocations and leave the others to run on a global dispatch queue.