swift 3 from working swift 2.3 : @escaping with optionals and calls needing error chain management

Question

I have optionals (NSError?) that are flagged by Xcode/Swift as non-escaping. These are called within a function (that has @escaping on its closure) by a second function (also with @escaping on its closure). The problem seems to be that the errors are not captured in the closure of either function and so Xcode/Swift is seeing them as potentially escaping.

Previous stack overflow posts had noted 'withoutActuallyEscaping' as a workaround. That no longer seems to be supported (Xcode version 8.2.1).

Refactoring to try to keep everything local to the function has not worked. I've also tried moving all of the NSError? to Error (via local enum), but that also hasn't worked.

The core problem is how to enable an error returned (via success/failure) from one function to the calling statement to be either captured locally and retained or tagged as escaping so that Swift/XCode can compile.

Again, this was working in Swift 2.3, so I'm looking for suggestions on how to refactor or what to look at for correctly handling these calls with NSError or Error.

This is part of a large code stack (about 25K lines). I'm posting part of the stack below (given Hamish's comment) to try and make the question clearer. Currently there are about 17-different variations of this error that are present in the code-stack.

public func fetchMostRecentSamples(ofTypes types: [HKSampleType], completion: @escaping HMTypedSampleBlock)
{
    let group = DispatchGroup()
    var samples = [HKSampleType: [MCSample]]()

    let updateSamples :  ((MCSampleArray, CacheExpiry) -> Void, (MCError) -> Void, HKSampleType, [MCSample], MCError) -> Void = {
        (success, failure, type, statistics, error) in
        guard error == nil else {
            failure(error)
            return
        }
        guard statistics.isEmpty == false else {
            failure(error)
            return
        }

        samples[type] = statistics
        success(MCSampleArray(samples: statistics), .never)
    }

    let onStatistic : ((MCSampleArray, CacheExpiry) -> Void, (MCError) -> Void, HKSampleType) -> Void = { (success, failure, type) in
        self.fetchMostRecentSample(type) { (samples, error) in
            guard error == nil else {
                failure(error)
                return
            }

Then fetchMostRecentSample has this header: public func fetchMostRecentSample(_ sampleType: HKSampleType, completion: @escaping HMSampleBlock)

and the error message on the failure is "Closure use of non-escaping parameter 'failure' may allow it to escape" : "Parameter 'failure' is implicitly non-escaping"

Note that the let updateSamples is fine (not calling another function), but that the onStatistic with the failure (having error codes) is where the problem with escaping/non-escaping is coming from. MCError is an enum with the error codes (refactored from NSError? in Swift 2.3 version).

Major credits to Hamish for helping me to see into this. In case it helps others coming across this on their Swift 3 conversions, the other place that I stumbled was in assuming that all of our third-party pods were complete if they stated ready for Swift 3. In this case I had to update the AwesomeCache code to handle the errors correctly:

open func setObject(forKey key: String, cacheBlock: @escaping (@escaping(CacheBlockClosure), @escaping(ErrorClosure)) -> Void, completion: @escaping (T?, Bool, NSError?) -> Void) {
    if let object = object(forKey: key) {
        completion(object, true, nil)
    } else {
        let successBlock: CacheBlockClosure = { (obj, expires) in
            self.setObject(obj, forKey: key, expires: expires)
            completion(obj, false, nil)
        }

        let failureBlock: ErrorClosure = { (error) in
            completion(nil, false, error)
        }

        cacheBlock(successBlock, failureBlock)
    }
}

This is simply adding two more @escaping beyond what was in the github master. Otherwise, as Hamish pointed out, it comes down to paying attention to where @escaping needs to be added on the function calls. The update for AwesomeCache came from code like this:

aggregateCache.setObjectForKey(key, cacheBlock: { success, failure in
        let doCache : ([MCAggregateSample], NSError?) -> Void = { (aggregates, error) in
            guard error == nil else {
                failure(error)
                return
            }
            success(MCAggregateArray(aggregates: aggregates), .Date(self.getCacheExpiry(period)))
        }

where the success, failure will be flagged as potentially escaping without the code changes on the AwesomeCache.