I'm having trouble with the integration of Objective-C and Swift. The Objective-C code uses MRC (not ARC). To boil down the issue to a simple example, imagine that I have an objective-C object that owns lots of other objects embedded in its state. It provides methods to return pointers to objects it owns. Since it does not relinquish ownership, all of these objects do not see retain or autorelease messages when they are being returned.
The flow of control takes me through code in this order
A (objective-C) calls B (Closure in Swift) and B calls C (method in Objective-C)
The sequence of calls is supposed to get a value (pointer to object) from the call to C.
Imagine that the big container class has a method (C above)
-(id)getObject:(NSUInteger)identifier
The method has been tagged for swift with:
-(__unsafe_unretained id)getObject:(NSUInteger)identifier
to indicate that the object returned should not be subjected to ARC (at least, that was my hope... It does not seem to be the case).
Now, I write a closure in swift as follows (I simplified to keep the essence) (That's B in the example):
{ k -> container.getObject(k) }
And that closure is passed to Objective-C code (A in the example) and is being called from objective-C. What I was hoping for is: no ARC "interference". But that's not the case! If I rewrite the swift closure to:
{ k -> unowned let rv = container.getObject(k); return rv}
Things are a little better (retain/release calls originating from swift code disappear), but I still get into trouble, because it seems that the compiler creates another Objective-C Block to bridge with Swift closures.
See the fragment below (lifted from lldb backtrace)
#0 0x0000000100159210 in partial apply forwarder for queensNaiveSwift.(closure #1).(closure #4) ()
#1 0x000000010015b627 in reabstraction thunk helper from @callee_owned () -> (@owned ObjectiveC.ORIntVar) to @callee_unowned @objc_block () -> (@autoreleased ObjectiveC.ORIntVar) ()
There is this "Reabstraction thunk helper" which (as I understand it) is a compiler generated objective-C block that wraps the Swift closure. As you see, its 'type' betrays the fact that the return value (type ORIntVar in reality) is @autoreleased. Looking at the assembly confirms that there is a call to autorelease. But the entire thing was written to avoid ARC. Bottom line, the thunk helper is sending my object an autorelease. That puts the object in a global auto-release pool (which defeats the purpose and delays the release). Adding a temporary autoreleasepool is not the solution here. I simply do not wish to receive retain/release/autorelease.
So... How do I tell the Swift compiler to not generate auto-release in its thunks? The value coming back is __unretained_unsafe (and unowned in Swift). Why does the thunk feel compelled to do anything with this pointer? It should be a simple pass-through, no funny business. (Also, I'd rather avoid being forced to pepper the Swift code with unowned let x = ...
Any hint/explanation is much appreciated.