Properly support operating with nil asyncDelegate for Table & Collection.

Author: Scott Goodson

AsyncDisplayKit/ASCollectionView.mm

@@ -61,12 +61,14 @@ static BOOL _isInterceptedSelector(SEL sel)
  */
 @interface _ASCollectionViewProxy : NSProxy
 - (instancetype)initWithTarget:(id<NSObject>)target interceptor:(ASCollectionView *)interceptor;
+@property (nonatomic, weak) id<NSObject> target;
 @end
 
 @implementation _ASCollectionViewProxy {
   id<NSObject> __weak _target;
   ASCollectionView * __weak _interceptor;
 }
+@synthesize target = _target;
 
 - (instancetype)initWithTarget:(id<NSObject>)target interceptor:(ASCollectionView *)interceptor
 {
@@ -202,6 +204,14 @@ - (instancetype)initWithFrame:(CGRect)frame collectionViewLayout:(UICollectionVi
   // and should not trigger a relayout.
   _ignoreMaxSizeChange = CGSizeEqualToSize(_maxSizeForNodesConstrainedSize, CGSizeZero);
 
+  // Set up the delegate / dataSource proxy now, so we recieve key method calls from UITableView even if
+  // our owner never sets up asyncDelegate (technically the dataSource is required)
+  _proxyDelegate = [[_ASCollectionViewProxy alloc] initWithTarget:[NSNull null] interceptor:self];
+  super.delegate = (id<UICollectionViewDelegate>)_proxyDelegate;
+  
+  _proxyDataSource = [[_ASCollectionViewProxy alloc] initWithTarget:[NSNull null] interceptor:self];
+  super.dataSource = (id<UICollectionViewDataSource>)_proxyDataSource;
+
   self.backgroundColor = [UIColor whiteColor];
 
   [self registerClass:[UICollectionViewCell class] forCellWithReuseIdentifier:@"_ASCollectionViewCell"];
@@ -252,22 +262,21 @@ - (void)setAsyncDataSource:(id<ASCollectionViewDataSource>)asyncDataSource
   // Note: It's common to check if the value hasn't changed and short-circuit but we aren't doing that here to handle
   // the (common) case of nilling the asyncDataSource in the ViewController's dealloc. In this case our _asyncDataSource
   // will return as nil (ARC magic) even though the _proxyDataSource still exists. It's really important to nil out
-  // super.dataSource in this case because calls to _ASTableViewProxy will start failing and cause crashes.
+  // _proxyDataSource.target in this case because calls to _ASCollectionViewProxy will start failing and cause crashes.
 
   if (asyncDataSource == nil) {
-    super.dataSource = nil;
+    _proxyDataSource.target = nil;
     _asyncDataSource = nil;
-    _proxyDataSource = nil;
     _asyncDataSourceImplementsConstrainedSizeForNode = NO;
   } else {
+    _proxyDataSource.target = asyncDataSource;
     _asyncDataSource = asyncDataSource;
+    _asyncDataSourceImplementsConstrainedSizeForNode = ([_asyncDataSource respondsToSelector:@selector(collectionView:constrainedSizeForNodeAtIndexPath:)] ? 1 : 0);
+    
     // TODO: Support supplementary views with ASCollectionView.
     if ([_asyncDataSource respondsToSelector:@selector(collectionView:viewForSupplementaryElementOfKind:atIndexPath:)]) {
       ASDisplayNodeAssert(NO, @"ASCollectionView is planned to support supplementary views by September 2015.  You can work around this issue by using standard items.");
     }
-    _proxyDataSource = [[_ASCollectionViewProxy alloc] initWithTarget:_asyncDataSource interceptor:self];
-    super.dataSource = (id<UICollectionViewDataSource>)_proxyDataSource;
-    _asyncDataSourceImplementsConstrainedSizeForNode = ([_asyncDataSource respondsToSelector:@selector(collectionView:constrainedSizeForNodeAtIndexPath:)] ? 1 : 0);
   }
 }
 
@@ -276,19 +285,17 @@ - (void)setAsyncDelegate:(id<ASCollectionViewDelegate>)asyncDelegate
   // Note: It's common to check if the value hasn't changed and short-circuit but we aren't doing that here to handle
   // the (common) case of nilling the asyncDelegate in the ViewController's dealloc. In this case our _asyncDelegate
   // will return as nil (ARC magic) even though the _proxyDelegate still exists. It's really important to nil out
-  // super.delegate in this case because calls to _ASTableViewProxy will start failing and cause crashes.
+  // _proxyDelegate.target in this case because calls to _ASCollectionViewProxy will start failing and cause crashes.
 
   if (asyncDelegate == nil) {
     // order is important here, the delegate must be callable while nilling super.delegate to avoid random crashes
     // in UIScrollViewAccessibility.
-    super.delegate = nil;
+    _proxyDelegate.target = nil;
     _asyncDelegate = nil;
-    _proxyDelegate = nil;
     _asyncDelegateImplementsInsetSection = NO;
   } else {
+    _proxyDelegate.target = asyncDelegate;
     _asyncDelegate = asyncDelegate;
-    _proxyDelegate = [[_ASCollectionViewProxy alloc] initWithTarget:_asyncDelegate interceptor:self];
-    super.delegate = (id<UICollectionViewDelegate>)_proxyDelegate;
     _asyncDelegateImplementsInsetSection = ([_asyncDelegate respondsToSelector:@selector(collectionView:layout:insetForSectionAtIndex:)] ? 1 : 0);
   }
 }

AsyncDisplayKit/ASTableView.mm

@@ -59,12 +59,14 @@ static BOOL _isInterceptedSelector(SEL sel)
  */
 @interface _ASTableViewProxy : NSProxy
 - (instancetype)initWithTarget:(id<NSObject>)target interceptor:(ASTableView *)interceptor;
+@property (nonatomic, weak) id<NSObject> target;
 @end
 
 @implementation _ASTableViewProxy {
   id<NSObject> __weak _target;
   ASTableView * __weak _interceptor;
 }
+@synthesize target = _target;
 
 - (instancetype)initWithTarget:(id<NSObject>)target interceptor:(ASTableView *)interceptor
 {
@@ -218,6 +220,14 @@ - (void)configureWithAsyncDataFetching:(BOOL)asyncDataFetchingEnabled
   // If the initial size is 0, expect a size change very soon which is part of the initial configuration
   // and should not trigger a relayout.
   _ignoreMaxWidthChange = (_maxWidthForNodesConstrainedSize == 0);
+  
+  // Set up the delegate / dataSource proxy now, so we recieve key method calls from UITableView even if
+  // our owner never sets up asyncDelegate (technically the dataSource is required)
+  _proxyDelegate = [[_ASTableViewProxy alloc] initWithTarget:[NSNull null] interceptor:self];
+  super.delegate = (id<UITableViewDelegate>)_proxyDelegate;
+  
+  _proxyDataSource = [[_ASTableViewProxy alloc] initWithTarget:[NSNull null] interceptor:self];
+  super.dataSource = (id<UITableViewDataSource>)_proxyDataSource;
 }
 
 - (instancetype)initWithFrame:(CGRect)frame style:(UITableViewStyle)style
@@ -277,16 +287,14 @@ - (void)setAsyncDataSource:(id<ASTableViewDataSource>)asyncDataSource
   // Note: It's common to check if the value hasn't changed and short-circuit but we aren't doing that here to handle
   // the (common) case of nilling the asyncDataSource in the ViewController's dealloc. In this case our _asyncDataSource
   // will return as nil (ARC magic) even though the _proxyDataSource still exists. It's really important to nil out
-  // super.dataSource in this case because calls to _ASTableViewProxy will start failing and cause crashes.
+  // _proxyDataSource.target in this case because calls to _ASTableViewProxy will start failing and cause crashes.
 
   if (asyncDataSource == nil) {
-    super.dataSource = nil;
+    _proxyDataSource.target = nil;
     _asyncDataSource = nil;
-    _proxyDataSource = nil;
   } else {
+    _proxyDataSource.target = asyncDataSource;
     _asyncDataSource = asyncDataSource;
-    _proxyDataSource = [[_ASTableViewProxy alloc] initWithTarget:_asyncDataSource interceptor:self];
-    super.dataSource = (id<UITableViewDataSource>)_proxyDataSource;
   }
 }
 
@@ -295,18 +303,16 @@ - (void)setAsyncDelegate:(id<ASTableViewDelegate>)asyncDelegate
   // Note: It's common to check if the value hasn't changed and short-circuit but we aren't doing that here to handle
   // the (common) case of nilling the asyncDelegate in the ViewController's dealloc. In this case our _asyncDelegate
   // will return as nil (ARC magic) even though the _proxyDelegate still exists. It's really important to nil out
-  // super.delegate in this case because calls to _ASTableViewProxy will start failing and cause crashes.
+  // _proxyDelegate.target in this case because calls to _ASTableViewProxy will start failing and cause crashes.
 
   if (asyncDelegate == nil) {
     // order is important here, the delegate must be callable while nilling super.delegate to avoid random crashes
     // in UIScrollViewAccessibility.
-    super.delegate = nil;
+    _proxyDelegate.target = nil;
     _asyncDelegate = nil;
-    _proxyDelegate = nil; 
   } else {
+    _proxyDelegate.target = asyncDelegate;
     _asyncDelegate = asyncDelegate;
-    _proxyDelegate = [[_ASTableViewProxy alloc] initWithTarget:asyncDelegate interceptor:self];
-    super.delegate = (id<UITableViewDelegate>)_proxyDelegate;
   }
 }