s/(ActionDisposable|SimpleDisposable)/AnyDisposable/g.

Author: andersio

CHANGELOG.md

@@ -1,5 +1,6 @@
 # master
 *Please add new entries at the top.*
+1. `ActionDisposable` and `SimpleDisposable` have been folded into `AnyDisposable`. (#412, kudos to @andersio)
 
 # 1.1.3
 ## Deprecation

Sources/Deprecations+Removals.swift

@@ -3,6 +3,11 @@ import Dispatch
 import Result
 
 // MARK: Unavailable methods in ReactiveSwift 2.0.
+extension AnyDisposable {
+	@available(*, unavailable, renamed:"init(_:)")
+	public convenience init(action: @escaping () -> Void) { fatalError() }
+}
+
 extension Lifetime {
 	@available(*, unavailable, renamed:"hasEnded")
 	public var isDisposed: Bool { fatalError() }
@@ -132,6 +137,12 @@ public func timer(interval: DispatchTimeInterval, on scheduler: DateScheduler) -
 public func timer(interval: DispatchTimeInterval, on scheduler: DateScheduler, leeway: DispatchTimeInterval) -> SignalProducer<Date, NoError> { fatalError() }
 
 // MARK: Obsolete types in ReactiveSwift 2.0.
+@available(*, unavailable, renamed:"AnyDisposable")
+public typealias SimpleDisposable = AnyDisposable
+
+@available(*, unavailable, renamed:"AnyDisposable")
+public typealias ActionDisposable = AnyDisposable
+
 @available(*, unavailable, renamed:"Signal.Event")
 public typealias Event<Value, Error: Swift.Error> = Signal<Value, Error>.Event
 

Sources/Disposable.swift

@@ -40,68 +40,80 @@ extension UnsafeAtomicState where State == DisposableState {
 
 /// A type-erased disposable that forwards operations to an underlying disposable.
 public final class AnyDisposable: Disposable {
-	private let disposable: Disposable
-
-	public var isDisposed: Bool {
-		return disposable.isDisposed
-	}
-
-	public init(_ disposable: Disposable) {
-		self.disposable = disposable
+	private enum Backing {
+		case wrapping(Disposable)
+
+		// We need to ability to release the closure. However, the way Swift packs multi-
+		// payload enum discriminator via both extra inhabitants and unused bits may 
+		// result in corrupted reads even after masking. So an unsafe allocation is used
+		// instead.
+		case action(UnsafeAtomicState<DisposableState>, UnsafeMutablePointer<() -> Void>?)
 	}
 
-	public func dispose() {
-		disposable.dispose()
-	}
-}
-
-/// A disposable that only flips `isDisposed` upon disposal, and performs no other
-/// work.
-public final class SimpleDisposable: Disposable {
-	private var state = UnsafeAtomicState(DisposableState.active)
+	private let base: Backing
 
 	public var isDisposed: Bool {
-		return state.is(.disposed)
+		switch base {
+		case let .action(state, _):
+			return state.is(.disposed)
+		case let .wrapping(disposable):
+			return disposable.isDisposed
+		}
 	}
 
-	public init() {}
+	/// Create a disposable which runs the given action upon disposal.
+	///
+	/// - parameters:
+	///   - action: A closure to run when calling `dispose()`.
+	public init(_ action: @escaping () -> Void) {
+		let actionPointer = UnsafeMutablePointer<() -> Void>.allocate(capacity: 1)
+		actionPointer.initialize(to: action)
 
-	public func dispose() {
-		_ = state.tryDispose()
+		base = .action(UnsafeAtomicState(DisposableState.active), actionPointer)
 	}
 
-	deinit {
-		state.deinitialize()
+	/// Create a disposable.
+	public init() {
+		base = .action(UnsafeAtomicState(DisposableState.active), nil)
 	}
-}
-
-/// A disposable that will run an action upon disposal.
-public final class ActionDisposable: Disposable {
-	private var action: (() -> Void)?
-	private var state: UnsafeAtomicState<DisposableState>
 
-	public var isDisposed: Bool {
-		return state.is(.disposed)
-	}
-
-	/// Initialize the disposable to run the given action upon disposal.
+	/// Create a disposable which wraps the given disposable.
 	///
 	/// - parameters:
-	///   - action: A closure to run when calling `dispose()`.
-	public init(action: @escaping () -> Void) {
-		self.action = action
-		self.state = UnsafeAtomicState(DisposableState.active)
+	///   - disposable: The disposable to be wrapped.
+	public init(_ disposable: Disposable) {
+		base = .wrapping(disposable)
 	}
 
-	public func dispose() {
-		if state.tryDispose() {
-			action?()
-			action = nil
+	deinit {
+		switch base {
+		case let .action(state, actionPointer):
+			if !state.is(.disposed) {
+				actionPointer?.deinitialize()
+				actionPointer?.deallocate(capacity: 1)
+			}
+
+			state.deinitialize()
+
+		case .wrapping:
+			break
 		}
 	}
 
-	deinit {
-		state.deinitialize()
+	public func dispose() {
+		switch base {
+		case let .action(state, actionPointer):
+			if state.tryDispose() {
+				if let pointer = actionPointer {
+					pointer.pointee()
+					pointer.deinitialize()
+					pointer.deallocate(capacity: 1)
+				}
+			}
+
+		case let .wrapping(disposable):
+			disposable.dispose()
+		}
 	}
 }
 
@@ -179,7 +191,7 @@ public final class CompositeDisposable: Disposable {
 			guard disposables != nil else { return nil }
 
 			let token = disposables!.insert(d)
-			return ActionDisposable { [weak self] in
+			return AnyDisposable { [weak self] in
 				self?.disposables.modify {
 					$0?.remove(using: token)
 				}
@@ -197,12 +209,51 @@ public final class CompositeDisposable: Disposable {
 	///            `disposable` is `nil`.
 	@discardableResult
 	public func add(_ action: @escaping () -> Void) -> Disposable? {
-		return add(ActionDisposable(action: action))
+		return add(AnyDisposable(action))
 	}
 
 	deinit {
 		state.deinitialize()
 	}
+
+	/// Adds the right-hand-side disposable to the left-hand-side
+	/// `CompositeDisposable`.
+	///
+	/// ````
+	///  disposable += producer
+	///      .filter { ... }
+	///      .map    { ... }
+	///      .start(observer)
+	/// ````
+	///
+	/// - parameters:
+	///   - lhs: Disposable to add to.
+	///   - rhs: Disposable to add.
+	///
+	/// - returns: An instance of `DisposableHandle` that can be used to opaquely
+	///            remove the disposable later (if desired).
+	@discardableResult
+	public static func +=(lhs: CompositeDisposable, rhs: Disposable?) -> Disposable? {
+		return lhs.add(rhs)
+	}
+
+	/// Adds the right-hand-side `ActionDisposable` to the left-hand-side
+	/// `CompositeDisposable`.
+	///
+	/// ````
+	/// disposable += { ... }
+	/// ````
+	///
+	/// - parameters:
+	///   - lhs: Disposable to add to.
+	///   - rhs: Closure to add as a disposable.
+	///
+	/// - returns: An instance of `DisposableHandle` that can be used to opaquely
+	///            remove the disposable later (if desired).
+	@discardableResult
+	public static func +=(lhs: CompositeDisposable, rhs: @escaping () -> ()) -> Disposable? {
+		return lhs.add(rhs)
+	}
 }
 
 /// A disposable that, upon deinitialization, will automatically dispose of
@@ -246,6 +297,44 @@ extension ScopedDisposable where Inner == AnyDisposable {
 	}
 }
 
+extension ScopedDisposable where Inner == CompositeDisposable {
+	/// Adds the right-hand-side disposable to the left-hand-side
+	/// `ScopedDisposable<CompositeDisposable>`.
+	///
+	/// ````
+	/// disposable += { ... }
+	/// ````
+	///
+	/// - parameters:
+	///   - lhs: Disposable to add to.
+	///   - rhs: Disposable to add.
+	///
+	/// - returns: An instance of `DisposableHandle` that can be used to opaquely
+	///            remove the disposable later (if desired).
+	@discardableResult
+	public static func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: Disposable?) -> Disposable? {
+		return lhs.inner.add(rhs)
+	}
+
+	/// Adds the right-hand-side disposable to the left-hand-side
+	/// `ScopedDisposable<CompositeDisposable>`.
+	///
+	/// ````
+	/// disposable += { ... }
+	/// ````
+	///
+	/// - parameters:
+	///   - lhs: Disposable to add to.
+	///   - rhs: Closure to add as a disposable.
+	///
+	/// - returns: An instance of `DisposableHandle` that can be used to opaquely
+	///            remove the disposable later (if desired).
+	@discardableResult
+	public static func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: @escaping () -> ()) -> Disposable? {
+		return lhs.inner.add(rhs)
+	}
+}
+
 /// A disposable that disposes of its wrapped disposable, and allows its
 /// wrapped disposable to be replaced.
 public final class SerialDisposable: Disposable {
@@ -293,78 +382,3 @@ public final class SerialDisposable: Disposable {
 		state.deinitialize()
 	}
 }
-
-/// Adds the right-hand-side disposable to the left-hand-side
-/// `CompositeDisposable`.
-///
-/// ````
-///  disposable += producer
-///      .filter { ... }
-///      .map    { ... }
-///      .start(observer)
-/// ````
-///
-/// - parameters:
-///   - lhs: Disposable to add to.
-///   - rhs: Disposable to add.
-///
-/// - returns: An instance of `DisposableHandle` that can be used to opaquely
-///            remove the disposable later (if desired).
-@discardableResult
-public func +=(lhs: CompositeDisposable, rhs: Disposable?) -> Disposable? {
-	return lhs.add(rhs)
-}
-
-/// Adds the right-hand-side `ActionDisposable` to the left-hand-side
-/// `CompositeDisposable`.
-///
-/// ````
-/// disposable += { ... }
-/// ````
-///
-/// - parameters:
-///   - lhs: Disposable to add to.
-///   - rhs: Closure to add as a disposable.
-///
-/// - returns: An instance of `DisposableHandle` that can be used to opaquely
-///            remove the disposable later (if desired).
-@discardableResult
-public func +=(lhs: CompositeDisposable, rhs: @escaping () -> ()) -> Disposable? {
-	return lhs.add(rhs)
-}
-
-/// Adds the right-hand-side disposable to the left-hand-side
-/// `ScopedDisposable<CompositeDisposable>`.
-///
-/// ````
-/// disposable += { ... }
-/// ````
-///
-/// - parameters:
-///   - lhs: Disposable to add to.
-///   - rhs: Disposable to add.
-///
-/// - returns: An instance of `DisposableHandle` that can be used to opaquely
-///            remove the disposable later (if desired).
-@discardableResult
-public func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: Disposable?) -> Disposable? {
-	return lhs.inner.add(rhs)
-}
-
-/// Adds the right-hand-side disposable to the left-hand-side
-/// `ScopedDisposable<CompositeDisposable>`.
-///
-/// ````
-/// disposable += { ... }
-/// ````
-///
-/// - parameters:
-///   - lhs: Disposable to add to.
-///   - rhs: Closure to add as a disposable.
-///
-/// - returns: An instance of `DisposableHandle` that can be used to opaquely
-///            remove the disposable later (if desired).
-@discardableResult
-public func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: @escaping () -> ()) -> Disposable? {
-	return lhs.inner.add(rhs)
-}

Sources/Flatten.swift

@@ -444,7 +444,7 @@ extension Signal where Value: SignalProducerProtocol, Error == Value.Error {
 		func startNextIfNeeded() {
 			while let producer = state.modify({ $0.dequeue() }) {
 				let producerState = UnsafeAtomicState<ProducerState>(.starting)
-				let deinitializer = ScopedDisposable(ActionDisposable(action: producerState.deinitialize))
+				let deinitializer = ScopedDisposable(AnyDisposable(producerState.deinitialize))
 
 				producer.startWithSignal { signal, inner in
 					let handle = disposable.add(inner)

Sources/FoundationExtensions.swift

@@ -35,7 +35,7 @@ extension Reactive where Base: NotificationCenter {
 				observer.send(value: notification)
 			}
 
-			return ActionDisposable {
+			return AnyDisposable {
 				base.removeObserver(notificationObserver)
 			}
 		}