ReactiveObjc: Replace OSAtomic with stdatomic.

OSAtomic is deprecated as of iOS10. This change is mainly a cherry pick
of upstream PR: ReactiveCocoa#178.

Author: arangato

ReactiveObjC.xcodeproj/project.pbxproj

@@ -1967,7 +1967,7 @@
 			isa = PBXProject;
 			attributes = {
 				LastSwiftUpdateCheck = 0730;
-				LastUpgradeCheck = 0900;
+				LastUpgradeCheck = 1160;
 				ORGANIZATIONNAME = GitHub;
 				TargetAttributes = {
 					57A4D1AF1BA13D7A00F7D4B1 = {
@@ -1991,11 +1991,11 @@
 					};
 					D047260B19E49F82006002AA = {
 						CreatedOnToolsVersion = 6.1;
-						LastSwiftMigration = 0800;
+						LastSwiftMigration = 1160;
 					};
 					D047261519E49F82006002AA = {
 						CreatedOnToolsVersion = 6.1;
-						LastSwiftMigration = 0800;
+						LastSwiftMigration = 1160;
 					};
 				};
 			};

ReactiveObjC/NSObject+RACPropertySubscribing.m

@@ -17,7 +17,6 @@
 #import "RACSubscriber.h"
 #import "RACSignal+Operations.h"
 #import "RACTuple.h"
-#import <libkern/OSAtomic.h>
 
 @implementation NSObject (RACPropertySubscribing)
 

ReactiveObjC/RACCommand.m

@@ -17,16 +17,16 @@
 #import "RACScheduler.h"
 #import "RACSequence.h"
 #import "RACSignal+Operations.h"
-#import <libkern/OSAtomic.h>
+#import <stdatomic.h>
 
 NSString * const RACCommandErrorDomain = @"RACCommandErrorDomain";
 NSString * const RACUnderlyingCommandErrorKey = @"RACUnderlyingCommandErrorKey";
 
 const NSInteger RACCommandErrorNotEnabled = 1;
 
 @interface RACCommand () {
-  // Atomic backing variable for `allowsConcurrentExecution`.
-  volatile uint32_t _allowsConcurrentExecution;
+	// Atomic backing variable for `allowsConcurrentExecution`.
+	atomic_uint _allowsConcurrentExecution;
 }
 
 /// A subject that sends added execution signals.
@@ -54,11 +54,11 @@ - (BOOL)allowsConcurrentExecution {
 }
 
 - (void)setAllowsConcurrentExecution:(BOOL)allowed {
-  if (allowed) {
-    OSAtomicOr32Barrier(1, &_allowsConcurrentExecution);
-  } else {
-    OSAtomicAnd32Barrier(0, &_allowsConcurrentExecution);
-  }
+	if (allowed) {
+		atomic_fetch_or(&_allowsConcurrentExecution, 1);
+	} else {
+		atomic_fetch_and(&_allowsConcurrentExecution, 0);
+	}
 
   [self.allowsConcurrentExecutionSubject sendNext:@(_allowsConcurrentExecution)];
 }

ReactiveObjC/RACDisposable.m

@@ -8,15 +8,15 @@
 
 #import "RACDisposable.h"
 #import "RACScopedDisposable.h"
-#import <libkern/OSAtomic.h>
+#import <stdatomic.h>
 
 @interface RACDisposable () {
-  // A copied block of type void (^)(void) containing the logic for disposal,
-  // a pointer to `self` if no logic should be performed upon disposal, or
-  // NULL if the receiver is already disposed.
-  //
-  // This should only be used atomically.
-  void * volatile _disposeBlock;
+	// A copied block of type void (^)(void) containing the logic for disposal,
+	// a pointer to `self` if no logic should be performed upon disposal, or
+	// NULL if the receiver is already disposed.
+	//
+	// This should only be used atomically.
+	_Atomic(void *) _disposeBlock;
 }
 
 @end
@@ -34,8 +34,8 @@ - (BOOL)isDisposed {
 - (instancetype)init {
   self = [super init];
 
-  _disposeBlock = (__bridge void *)self;
-  OSMemoryBarrier();
+	_disposeBlock = (__bridge void *)self;
+	atomic_thread_fence(memory_order_seq_cst);
 
   return self;
 }
@@ -45,8 +45,8 @@ - (instancetype)initWithBlock:(void (^)(void))block {
 
   self = [super init];
 
-  _disposeBlock = (void *)CFBridgingRetain([block copy]); 
-  OSMemoryBarrier();
+	_disposeBlock = (void *)CFBridgingRetain([block copy]); 
+	atomic_thread_fence(memory_order_seq_cst);
 
   return self;
 }
@@ -67,12 +67,12 @@ - (void)dealloc {
 - (void)dispose {
   void (^disposeBlock)(void) = NULL;
 
-  while (YES) {
-    void *blockPtr = _disposeBlock;
-    if (OSAtomicCompareAndSwapPtrBarrier(blockPtr, NULL, &_disposeBlock)) {
-      if (blockPtr != (__bridge void *)self) {
-        disposeBlock = CFBridgingRelease(blockPtr);
-      }
+	while (YES) {
+		void *blockPtr = _disposeBlock;
+		if (atomic_compare_exchange_strong(&_disposeBlock, &blockPtr, NULL)) {
+			if (blockPtr != (__bridge void *)self) {
+				disposeBlock = CFBridgingRelease(blockPtr);
+			}
 
       break;
     }

ReactiveObjC/RACDynamicSequence.m

@@ -7,7 +7,7 @@
 //
 
 #import "RACDynamicSequence.h"
-#import <libkern/OSAtomic.h>
+#import <stdatomic.h>
 
 // Determines how RACDynamicSequences will be deallocated before the next one is
 // shifted onto the autorelease pool.
@@ -114,10 +114,10 @@ + (RACSequence *)sequenceWithLazyDependency:(id (^)(void))dependencyBlock headBl
 }
 
 - (void)dealloc {
-  static volatile int32_t directDeallocCount = 0;
+	static atomic_int directDeallocCount = 0;
 
-  if (OSAtomicIncrement32(&directDeallocCount) >= DEALLOC_OVERFLOW_GUARD) {
-    OSAtomicAdd32(-DEALLOC_OVERFLOW_GUARD, &directDeallocCount);
+	if (atomic_fetch_add(&directDeallocCount, 1) + 1 >= DEALLOC_OVERFLOW_GUARD) {
+		atomic_fetch_add(&directDeallocCount, -DEALLOC_OVERFLOW_GUARD);
 
     // Put this sequence's tail onto the autorelease pool so we stop
     // recursing.

ReactiveObjC/RACDynamicSignal.m

@@ -12,7 +12,6 @@
 #import "RACPassthroughSubscriber.h"
 #import "RACScheduler+Private.h"
 #import "RACSubscriber.h"
-#import <libkern/OSAtomic.h>
 
 @interface RACDynamicSignal ()
 

ReactiveObjC/RACMulticastConnection.m

@@ -11,20 +11,20 @@
 #import "RACDisposable.h"
 #import "RACSerialDisposable.h"
 #import "RACSubject.h"
-#import <libkern/OSAtomic.h>
+#import <stdatomic.h>
 
 @interface RACMulticastConnection () {
-  RACSubject *_signal;
-
-  // When connecting, a caller should attempt to atomically swap the value of this
-  // from `0` to `1`.
-  //
-  // If the swap is successful the caller is resposible for subscribing `_signal`
-  // to `sourceSignal` and storing the returned disposable in `serialDisposable`.
-  //
-  // If the swap is unsuccessful it means that `_sourceSignal` has already been
-  // connected and the caller has no action to take.
-  int32_t volatile _hasConnected;
+	RACSubject *_signal;
+
+	// When connecting, a caller should attempt to atomically swap the value of this
+	// from `0` to `1`.
+	//
+	// If the swap is successful the caller is resposible for subscribing `_signal`
+	// to `sourceSignal` and storing the returned disposable in `serialDisposable`.
+	//
+	// If the swap is unsuccessful it means that `_sourceSignal` has already been
+	// connected and the caller has no action to take.
+	_Atomic(BOOL) _hasConnected;
 }
 
 @property (nonatomic, readonly, strong) RACSignal *sourceSignal;
@@ -51,7 +51,8 @@ - (instancetype)initWithSourceSignal:(RACSignal *)source subject:(RACSubject *)s
 #pragma mark Connecting
 
 - (RACDisposable *)connect {
-  BOOL shouldConnect = OSAtomicCompareAndSwap32Barrier(0, 1, &_hasConnected);
+	BOOL expected = NO;
+	BOOL shouldConnect = atomic_compare_exchange_strong(&_hasConnected, &expected, YES);
 
   if (shouldConnect) {
     self.serialDisposable.disposable = [self.sourceSignal subscribe:_signal];
@@ -61,24 +62,24 @@ - (RACDisposable *)connect {
 }
 
 - (RACSignal *)autoconnect {
-  __block volatile int32_t subscriberCount = 0;
+	__block atomic_int subscriberCount = 0;
 
-  return [[RACSignal
-    createSignal:^(id<RACSubscriber> subscriber) {
-      OSAtomicIncrement32Barrier(&subscriberCount);
+	return [[RACSignal
+		createSignal:^(id<RACSubscriber> subscriber) {
+			atomic_fetch_add(&subscriberCount, 1);
 
       RACDisposable *subscriptionDisposable = [self.signal subscribe:subscriber];
       RACDisposable *connectionDisposable = [self connect];
 
       return [RACDisposable disposableWithBlock:^{
         [subscriptionDisposable dispose];
 
-        if (OSAtomicDecrement32Barrier(&subscriberCount) == 0) {
-          [connectionDisposable dispose];
-        }
-      }];
-    }]
-    setNameWithFormat:@"[%@] -autoconnect", self.signal.name];
+				if (atomic_fetch_sub(&subscriberCount, 1) - 1 == 0) {
+					[connectionDisposable dispose];
+				}
+			}];
+		}]
+		setNameWithFormat:@"[%@] -autoconnect", self.signal.name];
 }
 
 @end

ReactiveObjC/RACSignal+Operations.m

@@ -26,7 +26,7 @@
 #import "RACSubscriber.h"
 #import "RACTuple.h"
 #import "RACUnit.h"
-#import <libkern/OSAtomic.h>
+#import <stdatomic.h>
 #import <objc/runtime.h>
 #import <os/lock.h>
 
@@ -698,9 +698,9 @@ - (RACDisposable *)setKeyPath:(NSString *)keyPath onObject:(NSObject *)object ni
 
   RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
 
-  // Purposely not retaining 'object', since we want to tear down the binding
-  // when it deallocates normally.
-  __block void * volatile objectPtr = (__bridge void *)object;
+	// Purposely not retaining 'object', since we want to tear down the binding
+	// when it deallocates normally.
+	__block _Atomic(void *) objectPtr = (__bridge void *)object;
 
   RACDisposable *subscriptionDisposable = [self subscribeNext:^(id x) {
     // Possibly spec, possibly compiler bug, but this __bridge cast does not
@@ -750,13 +750,13 @@ - (RACDisposable *)setKeyPath:(NSString *)keyPath onObject:(NSObject *)object ni
     }
     #endif
 
-    while (YES) {
-      void *ptr = objectPtr;
-      if (OSAtomicCompareAndSwapPtrBarrier(ptr, NULL, &objectPtr)) {
-        break;
-      }
-    }
-  }];
+		while (YES) {
+			void *ptr = objectPtr;
+			if (atomic_compare_exchange_strong(&objectPtr, &ptr, NULL)) {
+				break;
+			}
+		}
+	}];
 
   [disposable addDisposable:clearPointerDisposable];
 
@@ -1150,36 +1150,36 @@ - (RACSignal *)subscribeOn:(RACScheduler *)scheduler {
 }
 
 - (RACSignal *)deliverOnMainThread {
-  return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
-    __block volatile int32_t queueLength = 0;
-    
-    void (^performOnMainThread)(dispatch_block_t) = ^(dispatch_block_t block) {
-      int32_t queued = OSAtomicIncrement32(&queueLength);
-      if (NSThread.isMainThread && queued == 1) {
-        block();
-        OSAtomicDecrement32(&queueLength);
-      } else {
-        dispatch_async(dispatch_get_main_queue(), ^{
-          block();
-          OSAtomicDecrement32(&queueLength);
-        });
-      }
-    };
-
-    return [self subscribeNext:^(id x) {
-      performOnMainThread(^{
-        [subscriber sendNext:x];
-      });
-    } error:^(NSError *error) {
-      performOnMainThread(^{
-        [subscriber sendError:error];
-      });
-    } completed:^{
-      performOnMainThread(^{
-        [subscriber sendCompleted];
-      });
-    }];
-  }] setNameWithFormat:@"[%@] -deliverOnMainThread", self.name];
+	return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
+		__block atomic_int queueLength = 0;
+		
+		void (^performOnMainThread)(dispatch_block_t) = ^(dispatch_block_t block) {
+			int32_t queued = atomic_fetch_add(&queueLength, 1) + 1;
+			if (NSThread.isMainThread && queued == 1) {
+				block();
+				atomic_fetch_sub(&queueLength, 1);
+			} else {
+				dispatch_async(dispatch_get_main_queue(), ^{
+					block();
+					atomic_fetch_sub(&queueLength, 1);
+				});
+			}
+		};
+
+		return [self subscribeNext:^(id x) {
+			performOnMainThread(^{
+				[subscriber sendNext:x];
+			});
+		} error:^(NSError *error) {
+			performOnMainThread(^{
+				[subscriber sendError:error];
+			});
+		} completed:^{
+			performOnMainThread(^{
+				[subscriber sendCompleted];
+			});
+		}];
+	}] setNameWithFormat:@"[%@] -deliverOnMainThread", self.name];
 }
 
 - (RACSignal *)groupBy:(id<NSCopying> (^)(id object))keyBlock transform:(id (^)(id object))transformBlock {