[swift-evolution] Should explicit `self.` be required when providing method as closure?

[Alex Johnson]

Hi list members,

During code review today, I noticed a really subtle memory leak that looked like:

    self.relatedObject = RelatedObject(callback: relatedObjectDidFinish)

Where `relatedObject` is a strong reference, `callback` is an escaping closure, and `relatedObjectDidFinish` is a method of `self`. From a memory management perspective, this code is equivalent to:

    self.relatedObject = RelatedObject(callback: { self.relatedObjectDidFinish })

In the second example, an explicit `self.` is required. It’s my understanding that this is to highlight that the closure keeps a strong reference to `self`. But, when passing a method, there is no such requirement, which makes it easier to accidentally create a retain cycle.

This made me wonder if an explicit `self.` should be required when passing a method as an escaping closure. And whether that would help in the same way that the explicit `self.` *inside* the closure is intended to.

If it were required, the code in the first example would be:

    self.relatedObject = RelatedObject(callback: self.relatedObjectDidFinish)

What do you think?

Alex Johnson
ajohnson at walmartlabs.com<mailto:ajohnson at walmartlabs.com>
ajohnson on Slack
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20170303/551b9cf0/attachment.html>