Comment by Blake (JIRA)

In Xcode 8.2.1, Swift 3 the compiler now outputs this.

```
Playground execution failed: error: Scratchpad.playground:2:38: error: single argument function types require parentheses
public func then<T,U,V>(closure: U -> V) -> Promise<T, V> {
^
()

error: Scratchpad.playground:5:25: error: type of expression is ambiguous without more context
let value = futureValue(input)
^~~~~~~~~~~~~~~~~~

error: Scratchpad.playground:6:20: error: closure use of non-escaping parameter 'closure' may allow it to escape
return closure(value)
^

Scratchpad.playground:2:29: note: parameter 'closure' is implicitly non-escaping
public func then<T,U,V>(closure: U -> V) -> Promise<T, V> {
^
@escaping
```

Reopening this because we still don't talk about the shadowing specifically.

Just chiming in with a +1 since this (and its dupes) have been open for awhile. I've hit this problem many times over the years. Sometimes I immediately recognize the issue, sometimes it takes a few minutes, and sometimes I need the eyes of a colleague to jolt my brain into proper diagnostic order, so I really wish the compiler would take care of this for me 🙂

struct Func<A, B> {
  let run: (A) -> B
}

extension Func {
  static func lift<A, B>(_ f: @escaping (A) -> B) -> Func {
    return Func(run: f)
  }
}

The diagnostics:

Cannot convert value of type '(A) -> IO<B>' to expected argument type '() -> IO<>'
Fix it: Insert ' as! () -> IO<>'

Maybe we lose the current fix-it, add warnings or errors per overshadowed generic (is there ever a reason to want to shadow a generic parameter?), and they can have fix-its to remove the shadowing?

Part of the inaction around any shadowing warnings is that there hasn't been a general discussion of what kinds of shadowing are okay and what aren't (a very subjective question), and that has the potential to be a sprawling discussion. I'm not sure we can agree to just deal with a little bit of it and ignore the rest, but if there's anywhere where it would make sense it would be this case: a member of a generic type whose generic parameters are exactly the same as the type's.