Closure use of non-escaping parameter may allow it to escape

Question

I have a protocol:

enum DataFetchResult {
    case success(data: Data)
    case failure
}

protocol DataServiceType {
    func fetchData(location: String, completion: (DataFetchResult) -> (Void))
    func cachedData(location: String) -> Data?
}

With an example implementation:

    /// An implementation of DataServiceType protocol returning predefined results using arbitrary queue for asynchronyous mechanisms.
    /// Dedicated to be used in various tests (Unit Tests).
    class DataMockService: DataServiceType {

        var result      : DataFetchResult
        var async       : Bool = true
        var queue       : DispatchQueue = DispatchQueue.global(qos: .background)
        var cachedData  : Data? = nil

        init(result : DataFetchResult) {
            self.result = result
        }

        func cachedData(location: String) -> Data? {
            switch self.result {
            case .success(let data):
                return data
            default:
                return nil
            }
        }

        func fetchData(location: String, completion: (DataFetchResult) -> (Void)) {

            // Returning result on arbitrary queue should be tested,
            // so we can check if client can work with any (even worse) implementation:

            if async == true {
                queue.async { [weak self ] in
                    guard let weakSelf = self else { return }

                    // This line produces compiler error: 
                    // "Closure use of non-escaping parameter 'completion' may allow it to escape"
                    completion(weakSelf.result)
                }
            } else {
               completion(self.result)
            }
        }
    }

The code above compiled and worked in Swift3 (Xcode8-beta5) but does not work with beta 6 anymore. Can you point me to the underlying cause?

Answer 1

This is due to a change in the default behaviour for parameters of function type. Prior to Swift 3 (specifically the build that ships with Xcode 8 beta 6), they would default to being escaping – you would have to mark them @noescape in order to prevent them from being stored or captured, which guarantees they won't outlive the duration of the function call.

However, now @noescape is the default for function-typed parameters. If you want to store or capture such functions, you now need to mark them @escaping :

protocol DataServiceType {
  func fetchData(location: String, completion:  (DataFetchResult) -> Void)
  func cachedData(location: String) -> Data?
}

func fetchData(location: String, completion:  (DataFetchResult) -> Void) {
  // ...
}

See the Swift Evolution proposal for more info about this change.

Answer 2

Since @noescape is the default, there 2 options to fix the error:

1) as @Hamish pointed out in his answer, just mark the completion as @escaping if you do care about the result and really want it to escape (that probably is the case in @Lukasz's question with Unit Tests as example and possibility of async completion)

func fetchData(location: String, completion: @escaping (DataFetchResult) -> Void)

OR

2) keep the default @noescape behavior by making the completion optional discarding the results altogether in cases when you don't care about the result. For example when user has already "walked away" and the calling view controller doesn't have to hang in memory just because there was some careless network call. Just as it was in my case when I came here looking for answer and the sample code wasn't very relevant for me, so marking @noescape was not the best option, event though it sounded as the only one from the first glance.

func fetchData(location: String, completion: ((DataFetchResult) -> Void)?) {
   ...
   completion?(self.result)
}