Optimizer not removing MainActor checks when calling into non-escaping closure

[harlanhaskins]

Description

Godbolt link showing the suboptimal codegen:

https://godbolt.org/z/cxMETnnWv

This also still reproduces with NonisolatedNonsendingByDefault enabled:

https://godbolt.org/z/4b9K3M6nv

Reproduction

The following code:

@MainActor
final class MyClass {
    var items: [Int] = []

    func isEven(_ number: Int) -> Bool {
        number.isMultiple(of: 2)
    }

    func numberOfEvens() -> Int {
        items.count {
            self.isEven($0)
        }
    }
}

Causes each iteration of the inlined inner loop from count(where:) to still check the executor at runtime to make sure we're on the main actor when calling into self.isEven.

Unfortunately the Typo app is seeing large amounts of time, sometimes upwards of 30% of frame execution time, spent dynamically checking the main actor executor.

Expected behavior

I would expect the compiler to recognize from the fact that count(where:)'s closure is non-escaping and synchronous that it will not escape the main actor, and therefore it should be able to deterministically elide runtime checks.

Environment

swift-driver version: 1.127.4.2 Apple Swift version 6.2 (swiftlang-6.2.0.9.909 clang-1700.3.9.907)
Target: arm64-apple-macosx26.0

Additional information

No response

[harlanhaskins]

This does not seem to be a 6.2 regression, this also happens in 6.1

[jamieQ]

in the case it helps with triage or workarounds, the following two variants appear to not produce the runtime executor checks:

making an extension method on Sequence:

extension Sequence {
    func myCount(where pred: (Element) -> Bool) -> Int {
        self.count(where: pred)
    }
}

// ...

    func numberOfEvens() -> Int {
        items.myCount {
            self.isEven($0)
        }
    }

avoiding using a closure literal:

func numberOfEvens() -> Int {
    let countWhere: ((Int) -> Bool) -> Int = items.count(where:)
    return countWhere(self.isEven(_:))
}