Apparent memory leak in FastEnumeration when deriving from NSMutableDictionary - objective-c

Question

I have a class that acts as a subclass of NSMutableDictionary (mostly by delegation) as we have some custom interfaces wrapped around a dictionary. When running the ios leak instrument it is identifying my keyEnumerator method as the source of the leak of NSFastEnumerationEnumerator objects.
Here is my keyEnumeration method as a delegate for the wrapped NSMutableDictionary.
- (NSEnumerator*) keyEnumerator {
return [dictionary keyEnumerator];
}
The backtrace for the leak always shows an enumerator as the source:
- (void) someMethod {
for (NSString *key in myWrappedDictionary) { ... }
}
Here is a typical backtrace:
calloc
class_createInstance
__CFAllocateObject2
-[__NSCFDictionary keyEnumerator]
-[WrappedDictionary keyEnumerator]
-[NSDictionary countByEnumerating...
-[SomeClass someMethod]
I'm looking for a workaround or flaw in my one line of code. I'm using ARC.
An example class is shown below. Invoking [WrappedDictionary createLeaks] will create 9 leaks.
#interface WrappedDictionary : NSMutableDictionary {
NSMutableDictionary *dictionary;
}
- (id) init;
- (NSUInteger) count;
- (NSEnumerator*) keyEnumerator;
- (void)setObject:(id)anObject forKey:(id)key;
#end
#implementation WrappedDictionary
- (id) init {
dictionary = [NSMutableDictionary new];
return self;
}
- (NSUInteger) count { return [dictionary count]; }
- (NSEnumerator*) keyEnumerator {
return [dictionary keyEnumerator];
}
- (void)setObject: anObject forKey:key {
[dictionary setObject:anObject forKey: key];
}
+ (void) createLeaks {
for (int i=0; i < 10; i++) {
WrappedDictionary *dict = [WrappedDictionary new];
[dict setObject:#"1" forKey:#"1"];
[dict setObject:#"2" forKey:#"2"];
[dict setObject:#"3" forKey:#"3"];
for (NSString *key in dict) {
NSLog(#"key=%#",key);
}
}
}
#end

Answer 1

Remember, the leaks instrument just shows where a leaked piece of memory is allocated. That doesn't mean that the allocation point is the source of the leak. The more likely source of the leak is in someMethod, or in the caller of someMethod, particularly if you put this into an ivar and then have a retain cycle on the entire object.

Answer 2

I have discovered a simple workaround.
If I change the keyEnumerator method from
- (NSEnumerator*) keyEnumerator {
return [dictionary keyEnumerator];
}
to
- (NSEnumerator*) keyEnumerator {
NSEnumerator *e = [dictionary keyEnumerator];
return e;
}
the leak goes away. This still does not make sense to me but it apparently forces the compiler to ARC properly the return from dictionary.