MainActor isolation is broken by conforming to an async protocol

[amarantedaniel]

Description
When a protocol with async functions is marked with the MainActor annotation, any implementation of this protocol that doesn't mark the functions as async as well when conforming to the protocol, will not execute on the MainActor.

Steps to reproduce
Given the following protocol and implementation:

@MainActor
protocol MyMainActorProtocol {
    func doStuff() async
}

struct MyMainActorStruct: MyMainActorProtocol {
    nonisolated init() {}
    func doStuff()  {
        print(">>> \(Thread.isMainThread)")
    }
}

When the following code is executed:

Task {
    let dependency: MyMainActorProtocol = MyMainActorStruct()
    print(">>> \(Thread.isMainThread)")
    await dependency.doStuff()
}

Both print statements run in a background thread.

But with the following adjustments of either

@MainActor
protocol MyMainActorProtocol {
    func doStuff()
}

struct MyMainActorStruct: MyMainActorProtocol {
    nonisolated init() {}
    func doStuff()  {
        print(">>> \(Thread.isMainThread)")
    }
}

or

@MainActor
protocol MyMainActorProtocol {
    func doStuff() async
}

struct MyMainActorStruct: MyMainActorProtocol {
    nonisolated init() {}
    func doStuff() async  {
        print(">>> \(Thread.isMainThread)")
    }
}

We get the correct result, where the body of the function inside the struct runs in the main thread.

Expected behavior
The expected behavior would be that any code that runs on the doStuff function in MyMainActorStruct would run on the main thread, as per the global actor inference rules

A non-actor type that conforms to a global-actor-qualified protocol within the same source file as its primary definition infers actor isolation from that protocol

Environment

• Swift compiler version info swift-driver version: 1.75.2 Apple Swift version 5.8 (swiftlang-5.8.0.124.2 clang-1403.0.22.11.100)
  Target: arm64-apple-macosx13.0
• Xcode version info Build version 14E222b
• Deployment target: iOS 16.4

Additional context
I have posted this question on both stackoverflow and the swift foruns and was asked to create an issue here (there's more information there).
https://forums.swift.org/t/weird-behavior-in-mainactor/67243
https://stackoverflow.com/questions/77089023/why-is-the-following-code-not-running-on-the-main-thread

[hborla]

This is the only way I can reproduce the issue now (and this example eliminates all dependencies except the standard library):

@MainActor
protocol MyMainActorProtocol {
  func doStuff() async
}

struct MyMainActorStruct: MyMainActorProtocol {
  nonisolated init() {}
  func doStuff()  {
    MainActor.assertIsolated()
  }
}

await Task.detached {
  let dependency: MyMainActorProtocol = MyMainActorStruct()

  await (MyMainActorStruct() as any MyMainActorProtocol).doStuff() // Trips the `MainActor.assertIsolated()` call

  await (MyMainActorStruct()).doStuff() // This line is fine
}.value

I think the the type checking here is fine. The issue here seems to be that the witness thunk for MyMainActorProtocol.doStuff does not hop to the main actor before calling MyMainActorStruct.doStuff.

[hborla]

Duplicate of #62394