<html><head><meta http-equiv="Content-Type" content="text/html charset=us-ascii"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class="">Under the umbrella of completing generics, I think we should make room for improving our diagnostics around protocol extensions. They're a well-received feature, but they introduce a lot of surprising behavior, and introduce opportunity for subtle bugs. We didn't have time to put much diagnostic work in last year, but now that users have had time to work with the feature, we have evidence of some of the more surprising and problematic behavior. Among the most common things we've seen reported:<div class=""><br class=""></div><div class="">A) When a protocol requirement has an extension implementation requirement available, we'll silently ignore when a conforming type attempts to conform to the protocol but misses, by type or spelling:</div><div class=""><br class=""></div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;" class=""><div class="">protocol Channel {</div><div class=""> func receive() -> NSData</div><div class="">}</div><div class="">extension Channel {</div><div class=""> func receive() -> NSData { return NSData() }</div><div class="">}</div><div class=""><br class=""></div><div class="">// Silently fails to replace the default implementation:</div><div class="">struct ClumsyChannel: Channel {</div><div class=""> // Wrong spelling</div><div class=""> func recieve() -> NSData { return NSData(bytes: "oops", length: 4) }</div><div class=""> // Wrong return type</div><div class=""> func receive() -> [UInt8] { return Array("whoopsie".utf8) }</div><div class=""> // Wrong throwiness</div><div class=""> func receive() throws -> NSData { throw "doh" }</div><div class="">}</div><div class=""><br class=""></div></blockquote>B) Protocol requirements aren't real class members, and can't be overridden by subclasses unless the base class satisfies the requirement with one of its own methods rather than with a protocol extension method, but we silently allow subclasses to shadow:<div class=""><br class=""></div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;" class=""><div class="">class BaseChannel: Channel { } // gets default imp from extension</div><div class=""><br class=""></div><div class="">class SubChannel: BaseChannel {</div><div class=""> // Doesn't 'override' protocol requirement; silently shadows it</div><div class=""> func receive() -> NSData { return NSData(bytes: "oof", length: 3) }</div><div class="">}</div><div class=""><br class=""></div></blockquote>C) Similarly, protocol extension methods aren't protocol requirements, so extension methods that don't match a requirement can't be specialized in a way available to generic code, but we silently allow concrete type implementations to shadow:<div class=""><br class=""></div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;" class=""><div class="">extension Channel {</div><div class=""> func receiveAsString() -> String {</div><div class=""> return String(data: receive(), encoding: NSUTF8Encoding)</div><div class=""> }</div><div class="">}</div><div class=""><br class=""></div><div class="">struct StringyChannel {</div><div class=""> func receive() -> NSData { return NSData(bytes: "data", 4) }</div><div class=""> // Does not affect generic code calling receiveAsString</div><div class=""> func receiveAsString() -> String { return "string" }</div><div class="">}</div><div class=""><br class=""></div><div class="">func foo<T: Channel>(chan: T) {</div><div class=""> print(chan.receiveAsString())</div><div class="">}</div><div class=""><br class=""></div><div class="">foo(StringyChannel()) // Prints "data"</div><div class=""><br class=""></div></blockquote>(B) and (C) could be mitigated by shadowing warnings, and we've also floated ideas for making them behave as intended, by implicitly forwarding protocol requirements into class methods to address (B) and/or introducing dynamic dispatch for protocol extensions to address (C). (A) is a bit trickier, since with overloading it's tricky to divine whether a declaration was really intended to match another one with a different type in isolation. We've discussed a couple approaches to this problem:<div class=""><br class=""></div><div class="">- Adopting an explicit 'implements' modifier, in the spirit of 'override', to mark a declaration as being intended to fulfill a requirement. This adds boilerplate we'd like to avoid, and also interferes with retroactive modeling.</div><div class="">- Encourage "one extension per conformance" style, where each protocol conformance's requirements are defined in a dedicated extension. We can then warn about any declarations in an extension that don't satisfy a requirement:</div><div class=""><br class=""></div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;" class=""><div class="">struct InconsistentChannel {}</div><div class=""><br class=""></div><div class="">extension InconsistentChannel: Channel {</div><div class=""> func receive() -> NSData { ... } // OK</div><div class=""> func recieve() -> NSData { ... } // Warning: Declaration in conformance extension doesn't satisfy any requirements from 'Channel'</div><div class=""> func receive() -> NSData? { ... } // Warning</div><div class="">}</div><div class=""><br class=""></div></blockquote>There are likely others too. It'd be great if we could give users better guidance about this feature.<div class=""><br class=""></div><div class="">-Joe</div></body></html>