Question

I’m having completely unexpected timing problems with the super simple code below. One of the variables is being autoreleased, and I have no clue why. I’m not using autorelease, KVO, etc. It shouldn’t be happening.

The WindowController is set as an @property (retain)‘d of MainController.

In the -dealloc of the MainController, I do self.windowController = nil;

But, it keeps waiting until the autorelease pool is flushed to release the windowController. I expect the WindowController’s dealloc to be called as soon as self.windowController = nil is done. Even if I wrap the [mainController release] in NSAutoreleasePool, it still doesn’t release right away.

Why is this happening?

---

This doesn’t seem like proper behavior for the @property / NSWindowController. Am I missing something?

---

Correction: It’s not bindings. I officially have no clue what the problem is.

Main driver:

[[MainController new] release];

MainController.h:

#import <Foundation/Foundation.h>
#import "WindowControllerSubclass.h"
@interface MainController : NSObject {
    WindowControllerSubclass *wc;
}

@property (retain) WindowControllerSubclass *wc;

@end

MainController.m:

#import "MainController.h"

@implementation MainController

@synthesize wc;

- (id)init {
    if (self = [super init]) {
        // This is problem here >>>  If I assign directly to wc, then it's not added to autorelease pool
        self.wc = [[WindowControllerSubclass alloc] init];
        [self.wc release]; // since it's (retain)'d
    }

    return self;
}

- (void) dealloc {
    self.wc = nil;
    NSLog(@"%@ deallocd (should be called after WC's dealloc)", [self className]);
}

@end

MainWindowControllerSubclass.h:

#import <Cocoa/Cocoa.h>

@interface WindowControllerSubclass : NSObject /* Not even NSWindowController */
@end

MainWindowControllerSubclass.m:

#import "WindowControllerSubclass.h"

@implementation WindowControllerSubclass

- (void) dealloc {
    NSLog(@"%@ deallocd", [self className]);
}

@end

Answer 1

There’s nothing strange about it, especially if your NSWindowController is in an autorelease pool.

An object (say x) is dealloc’ed when every object which owns it releases it. Autorelease is a deferred release, i.e. it doesn’t actually release until the autorelease pool is drained.

Consider the following chain of events:

    B creates x
    A owns x
    A autoreleases x. // x is not released; it's put on an autorelease pool
    B releases x.     // x is not dealloced yet, because x is not released by the autorelease pool
    autorelease pool is drained. x is sent another release message. nobody owns x. x is dealloc'd. 

That’s what you’re seeing.

— Update —

More, precisely, the mysterious usage of autorelease pool arises from your line

[self.wc release]; 

This uses the getter of wc, i.e. it calls [self wc]. Now, the default synthesized getter is implemented in this portion of obj-c runtime, in particular objc_getProperty_non_gc. Note that your property is (retain), i.e. it’s (atmomic retain). To guarantee atomicity, the getter retains the ivar and then returns it after autorelease‘ing it:

id *slot = (id*) ((char*)self + offset);
if (!atomic) return *slot;

// Atomic retain release world
spin_lock_t *slotlock = &PropertyLocks[GOODHASH(slot)];
_spin_lock(slotlock);
id value = objc_retain(*slot);
_spin_unlock(slotlock);

// for performance, we (safely) issue the autorelease OUTSIDE of the spinlock.
return objc_autoreleaseReturnValue(value);

That’s why it’s put on the autorelease pool. In any case,

obj.property=[[SomeClass alloc] init];
[obj.property release];

is a bad idea. In your case, self.ivar in the second line returned what you assigned in the first line, but that’s not guaranteed in the case of clever, non-synthesized accessors, or in a multi-threaded environment. When you do

obj.property=x;
id y=obj.property;

x and y can be different, if obj does some clever caching, or if there’s another thread accessing obj which changes obj.property between the two lines. So, use a temporary variable instead:

SomeClass* a=[[SomeClass alloc] init];
obj.property=a;
[a release];