[gardening] Remove unnecessary conditional code (#541)

Author: ikesyo

Sources/FoundationExtensions.swift

@@ -87,61 +87,35 @@ extension Date {
 
 extension DispatchTimeInterval {
 	internal var timeInterval: TimeInterval {
-		#if swift(>=3.2)
-			switch self {
-			case let .seconds(s):
-				return TimeInterval(s)
-			case let .milliseconds(ms):
-				return TimeInterval(TimeInterval(ms) / 1000.0)
-			case let .microseconds(us):
-				return TimeInterval(Int64(us) * Int64(NSEC_PER_USEC)) / TimeInterval(NSEC_PER_SEC)
-			case let .nanoseconds(ns):
-				return TimeInterval(ns) / TimeInterval(NSEC_PER_SEC)
-			case .never:
-				return .infinity
-			}
-		#else
-			switch self {
-			case let .seconds(s):
-				return TimeInterval(s)
-			case let .milliseconds(ms):
-				return TimeInterval(TimeInterval(ms) / 1000.0)
-			case let .microseconds(us):
-				return TimeInterval(Int64(us) * Int64(NSEC_PER_USEC)) / TimeInterval(NSEC_PER_SEC)
-			case let .nanoseconds(ns):
-				return TimeInterval(ns) / TimeInterval(NSEC_PER_SEC)
-			}
-		#endif
+		switch self {
+		case let .seconds(s):
+			return TimeInterval(s)
+		case let .milliseconds(ms):
+			return TimeInterval(TimeInterval(ms) / 1000.0)
+		case let .microseconds(us):
+			return TimeInterval(Int64(us) * Int64(NSEC_PER_USEC)) / TimeInterval(NSEC_PER_SEC)
+		case let .nanoseconds(ns):
+			return TimeInterval(ns) / TimeInterval(NSEC_PER_SEC)
+		case .never:
+			return .infinity
+		}
 	}
 
 	// This was added purely so that our test scheduler to "go backwards" in
 	// time. See `TestScheduler.rewind(by interval: DispatchTimeInterval)`.
 	internal static prefix func -(lhs: DispatchTimeInterval) -> DispatchTimeInterval {
-		#if swift(>=3.2)
-			switch lhs {
-			case let .seconds(s):
-				return .seconds(-s)
-			case let .milliseconds(ms):
-				return .milliseconds(-ms)
-			case let .microseconds(us):
-				return .microseconds(-us)
-			case let .nanoseconds(ns):
-				return .nanoseconds(-ns)
-			case .never:
-				return .never
-			}
-		#else
-			switch lhs {
-			case let .seconds(s):
-				return .seconds(-s)
-			case let .milliseconds(ms):
-				return .milliseconds(-ms)
-			case let .microseconds(us):
-				return .microseconds(-us)
-			case let .nanoseconds(ns):
-				return .nanoseconds(-ns)
-			}
-		#endif
+		switch lhs {
+		case let .seconds(s):
+			return .seconds(-s)
+		case let .milliseconds(ms):
+			return .milliseconds(-ms)
+		case let .microseconds(us):
+			return .microseconds(-us)
+		case let .nanoseconds(ns):
+			return .nanoseconds(-ns)
+		case .never:
+			return .never
+		}
 	}
 
 	/// Scales a time interval by the given scalar specified in `rhs`.

Sources/Property.swift

@@ -102,7 +102,6 @@ extension PropertyProtocol {
 		return lift { $0.map(transform) }
 	}
 
-#if swift(>=3.2)
 	/// Maps the current value and all subsequent values to a new property
 	/// by applying a key path.
 	///
@@ -113,7 +112,6 @@ extension PropertyProtocol {
 	public func map<U>(_ keyPath: KeyPath<Value, U>) -> Property<U> {
 		return lift { $0.map(keyPath) }
 	}
-#endif
 
 	/// Combines the current value and the subsequent values of two `Property`s in
 	/// the manner described by `Signal.combineLatest(with:)`.

Sources/Signal.swift

@@ -554,7 +554,6 @@ extension Signal {
 		return flatMapEvent(Signal.Event.map(transform))
 	}
 
-#if swift(>=3.2)
 	/// Map each value in the signal to a new value by applying a key path.
 	///
 	/// - parameters:
@@ -564,7 +563,6 @@ extension Signal {
 	public func map<U>(_ keyPath: KeyPath<Value, U>) -> Signal<U, Error> {
 		return map { $0[keyPath: keyPath] }
 	}
-#endif
 
 	/// Map errors in the signal to a new error.
 	///

Sources/SignalProducer.swift

@@ -809,7 +809,6 @@ extension SignalProducer {
 		return core.flatMapEvent(Signal.Event.map(transform))
 	}
 
-#if swift(>=3.2)
 	/// Map each value in the producer to a new value by applying a key path.
 	///
 	/// - parameters:
@@ -819,7 +818,6 @@ extension SignalProducer {
 	public func map<U>(_ keyPath: KeyPath<Value, U>) -> SignalProducer<U, Error> {
 		return core.flatMapEvent(Signal.Event.filterMap { $0[keyPath: keyPath] })
 	}
-#endif
 
 	/// Map errors in the producer to a new error.
 	///

Sources/UnidirectionalBinding.swift

@@ -149,7 +149,6 @@ public struct BindingTarget<Value>: BindingTargetProvider {
 		}
 	}
 
-	#if swift(>=3.2)
 	/// Creates a binding target which consumes values on the specified scheduler.
 	///
 	/// If no scheduler is specified, the binding target would consume the value
@@ -163,5 +162,4 @@ public struct BindingTarget<Value>: BindingTargetProvider {
 	public init<Object: AnyObject>(on scheduler: Scheduler = ImmediateScheduler(), lifetime: Lifetime, object: Object, keyPath: WritableKeyPath<Object, Value>) {
 		self.init(on: scheduler, lifetime: lifetime) { [weak object] in object?[keyPath: keyPath] = $0 }
 	}
-	#endif
 }

Tests/ReactiveSwiftTests/FoundationExtensionsSpec.swift

@@ -103,19 +103,15 @@ class FoundationExtensionsSpec: QuickSpec {
 
 				expect(DispatchTimeInterval.milliseconds(500).timeInterval).to(beCloseTo(0.5))
 				expect(DispatchTimeInterval.milliseconds(250).timeInterval).to(beCloseTo(0.25))
-				#if swift(>=3.2)
-					expect(DispatchTimeInterval.never.timeInterval) == Double.infinity
-				#endif
+				expect(DispatchTimeInterval.never.timeInterval) == Double.infinity
 			}
 
 			it("should negate as you'd hope") {
 				expect((-DispatchTimeInterval.seconds(1)).timeInterval).to(beCloseTo(-1.0))
 				expect((-DispatchTimeInterval.milliseconds(1)).timeInterval).to(beCloseTo(-0.001))
 				expect((-DispatchTimeInterval.microseconds(1)).timeInterval).to(beCloseTo(-0.000001, within: 0.0000001))
 				expect((-DispatchTimeInterval.nanoseconds(1)).timeInterval).to(beCloseTo(-0.000000001, within: 0.0000000001))
-				#if swift(>=3.2)
-					expect((-DispatchTimeInterval.never).timeInterval) == Double.infinity
-				#endif
+				expect((-DispatchTimeInterval.never).timeInterval) == Double.infinity
 			}
 		}
 	}

Tests/ReactiveSwiftTests/PropertySpec.swift

@@ -733,7 +733,6 @@ class PropertySpec: QuickSpec {
 					expect(mappedProperty.value) == 3
 				}
 
-#if swift(>=3.2)
 				it("should work with key paths") {
 					let property = MutableProperty("foo")
 					let mappedProperty = property.map(\.count)
@@ -742,7 +741,6 @@ class PropertySpec: QuickSpec {
 					property.value = "foobar"
 					expect(mappedProperty.value) == 6
 				}
-#endif
 			}
 
 			describe("combineLatest") {

Tests/ReactiveSwiftTests/SignalSpec.swift

@@ -506,7 +506,6 @@ class SignalSpec: QuickSpec {
 				expect(lastValue) == "2"
 			}
 
-#if swift(>=3.2)
 			it("should support key paths") {
 				let (signal, observer) = Signal<String, NoError>.pipe()
 				let mappedSignal = signal.map(\String.count)
@@ -524,7 +523,6 @@ class SignalSpec: QuickSpec {
 				observer.send(value: "foobar")
 				expect(lastValue) == 6
 			}
-#endif
 		}
 
 		describe("mapError") {

Tests/ReactiveSwiftTests/UnidirectionalBindingSpec.swift

@@ -80,7 +80,6 @@ class UnidirectionalBindingSpec: QuickSpec {
 				}
 			}
 
-			#if swift(>=3.2)
 			describe("key path binding target") {
 				var target: BindingTarget<Int>!
 				var object: Object!
@@ -112,7 +111,6 @@ class UnidirectionalBindingSpec: QuickSpec {
 					expect(object.value) == 2
 				}
 			}
-			#endif
 
 			it("should not deadlock on the same queue") {
 				var value: Int?