 			}
 		}
 	}
-
+}
+
+// FIXME: SWIFT_COMPILER_ISSUE
+//
+// Two of the `SignalProducer.then(self:_:)` overloads are kept in the protocol
+// to mitigate an overloading issue. Moving them back to the concrete type would
+// be a binary-breaking, source-compatible change.
+
+extension SignalProducerProtocol {
 	/// Wait for completion of `self`, *then* forward all events from
 	/// `replacement`. Any failure or interruption sent from `self` is
 	/// forwarded immediately, in which case `replacement` will not be started,

		return lift { $0.timeout(after: interval, raising: error, on: scheduler) }
	}

	/// Wait for completion of `self`, *then* forward all events from
	/// `replacement`.
	///
	/// - note: All values sent from `self` are ignored.
	///
	/// - parameters:
	///   - replacement: A producer to start when `self` completes.
	///
	/// - returns: A producer that sends events from `self` and then from
	///            `replacement` when `self` completes.
	public func then<U, NewError: Swift.Error>(_ replacement: SignalProducer<U, NewError>) -> SignalProducer<U, NewError> {
		return self
			.promoteErrors(NewError.self)
			.then(replacement)
	}

	/// Apply a failable `operation` to values from `self` with successful
	/// results forwarded on the returned producer and thrown errors sent as
	/// failed events.

	/// - returns: A `SignalProducer` that will forward `success`ful `result` as
	///            `value` event and then complete or `failed` event if `result`
	///            is a `failure`.
	public static func attempt(_ operation: @escaping () -> Result<Value, Error>) -> SignalProducer<Value, Error> {
		return SignalProducer<Value, Error> { observer, disposable in
			operation().analysis(ifSuccess: { value in
				observer.send(value: value)
				observer.sendCompleted()
