@swift-ci create

Just an update with what we are seeing on the 2020-05-22 master snapshot.

struct User {
    let email: String
}

let users = [User]()
let f3 = \User.email as (User) -> String // Cannot convert value of type 'KeyPath<User, String>' to type '(User) -> String' in coercion
users.map(f3)

[1, nil, 3, nil, 5].compactMap(\.self) // Cannot convert value of type 'WritableKeyPath<_, _>' to expected argument type '(Int?) throws -> ElementOfResult?'
// Cannot infer key path type from context; consider explicitly specifying a root type fix-it root
// Generic parameter 'ElementOfResult' could not be inferred

let x: [Int] = [1, nil, 3, nil, 5].compactMap(\.self) // Cannot convert value of type 'WritableKeyPath<_, _>' to expected argument type '(Int?) throws -> Int?'
// Cannot infer key path type from context; consider explicitly specifying a root type.

On investigation, the \User.email issue seems to be separate from the .self one. Since you said .self is more important to you, I've cloned the \User.email issue as SR-12991 and we'll use this report solely to track the .self bug.

In a near-release/5.3 Swift, I see better diagnostics but not better behavior:

<stdin>:1:1: error: generic parameter 'ElementOfResult' could not be inferred
[1, nil, 3, nil, 5].compactMap(\.self)
^
Swift.Sequence:2:28: note: in call to function 'compactMap'
    @inlinable public func compactMap<ElementOfResult>(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
                           ^
<stdin>:1:32: error: cannot convert value of type 'WritableKeyPath<_, _>' to expected argument type '(Int?) throws -> ElementOfResult?'
[1, nil, 3, nil, 5].compactMap(\.self)
                               ^
<stdin>:1:32: error: cannot infer key path type from context; consider explicitly specifying a root type
[1, nil, 3, nil, 5].compactMap(\.self)
                               ^
                                <#Root#>

The problem appears to be specific to self. For instance, this compiles just fine:

extension Optional { var mySelf: Self { self } }

[1, nil, 3, nil, 5].compactMap(\.mySelf)

Whereas even simpler .self expressions, like [1, 3, 5].map(.self), fail.

Comment by Michael Ozeryansky (JIRA)

brentdax (JIRA User) Awesome, thanks. I'm glad there's a slight workaround if I really want the syntax, good find.

Looks like duplicates:

https://bugs.swift.org/browse/SR-12387
https://bugs.swift.org/browse/SR-13999

Comment by Frederick Kellison-Linn (JIRA)

It looks to me like this happens during constraint simplification when the entire key path literal can be resolved before we have the necessary external context to determine whether the literal should be a function or a key path. In such a situation we assume that it will resolve to a key path... but in a situation like `.self` we can trivially resolve the keypath during constraint generation and so we never even have a chance to get the function type context.

I think this has been fixed by combination of the following PRs - #69742, #69742. All of the expressions mentioned in the description now type-check.

Please use the latest main compiler snapshot to verify and re-open.