Unexpected #selector() Behavior in Swift-Objective-C Interop?

Question

I've encountered an unexpected behavior while working with Swift and Objective-C interoperability involving the #selector() expression. Typically, when using #selector(), I understand that it's common to specify the type (class or instance) that declares the method to help the compiler identify the correct selector.

However, I noticed that in certain scenarios, I can use #selector() without explicitly qualifying the selector with a type, especially when referencing methods within the same class or with @objc annotated members.

Here's an example that works as expected:

class MyClass: NSObject {
    @objc func myMethod() {
        let selector = #selector(myMethod)
    }
}

While the above code works fine, I encountered an unusual behavior when trying to use #selector() within a Swift extension of an @objc class or when bridging between Swift and Objective-C.

Could someone explain the underlying mechanics and potential pitfalls of using #selector() in these specific contexts? Are there any best practices or alternative approaches to ensure safe and consistent behavior across different scenarios?

I tried using the #selector() expression in various scenarios:

1. Within the same class without specifying the type.
2. Within a Swift extension of an @objc class.
3. When bridging between Swift and Objective-C.

I expected the #selector() expression to work consistently across all scenarios, either requiring or not requiring the type specification based on Swift's interoperability rules with Objective-C.

I encountered unexpected behavior where:

1. #selector() worked without specifying the type within the same class.
2. #selector() failed to work within a Swift extension of an @objc class or when bridging between Swift and Objective-C.

I'm looking to understand the underlying mechanics, potential pitfalls, and best practices for using #selector() in these specific contexts to ensure safe and consistent behavior.