Adds deprecated warnings to API parts that were missing it. ReactiveX#1427

Author: kzaher

RxSwift/Deprecated.swift

@@ -38,15 +38,14 @@ extension Observable {
 extension ObservableType {
     /**
 
-    ** @available(*, deprecated, message: "Please use enumerated().map()", renamed: "enumerated().map()") **
-
-     Projects each element of an observable sequence into a new form by incorporating the element's index.
+    Projects each element of an observable sequence into a new form by incorporating the element's index.
 
      - seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
 
      - parameter selector: A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
      - returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
      */
+    @available(*, deprecated, message: "Please use enumerated().map()")
     public func mapWithIndex<R>(_ selector: @escaping (E, Int) throws -> R)
         -> Observable<R> {
         return enumerated().map { try selector($0.element, $0.index) }
@@ -55,24 +54,21 @@ extension ObservableType {
 
     /**
 
-     ** @available(*, deprecated, message: "Please use enumerated().flatMap()", renamed: "enumerated().flatMap()") **
-
      Projects each element of an observable sequence to an observable sequence by incorporating the element's index and merges the resulting observable sequences into one observable sequence.
 
      - seealso: [flatMap operator on reactivex.io](http://reactivex.io/documentation/operators/flatmap.html)
 
      - parameter selector: A transform function to apply to each element; the second parameter of the function represents the index of the source element.
      - returns: An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
      */
+    @available(*, deprecated, message: "Please use enumerated().flatMap()")
     public func flatMapWithIndex<O: ObservableConvertibleType>(_ selector: @escaping (E, Int) throws -> O)
         -> Observable<O.E> {
         return enumerated().flatMap { try selector($0.element, $0.index) }
     }
 
     /**
 
-     ** @available(*, deprecated, message: "Please use enumerated().skipWhile().map()", renamed: "enumerated().skipWhile().map()") **
-     
      Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements.
      The element's index is used in the logic of the predicate function.
 
@@ -81,15 +77,14 @@ extension ObservableType {
      - parameter predicate: A function to test each element for a condition; the second parameter of the function represents the index of the source element.
      - returns: An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.
      */
+    @available(*, deprecated, message: "Please use enumerated().skipWhile().map()")
     public func skipWhileWithIndex(_ predicate: @escaping (E, Int) throws -> Bool) -> Observable<E> {
         return enumerated().skipWhile { try predicate($0.element, $0.index) }.map { $0.element }
     }
 
 
     /**
-     
-     ** @available(*, deprecated, message: "Please use enumerated().takeWhile().map()", renamed: "enumerated().takeWhile().map()") **
-     
+
      Returns elements from an observable sequence as long as a specified condition is true.
 
      The element's index is used in the logic of the predicate function.
@@ -99,6 +94,7 @@ extension ObservableType {
      - parameter predicate: A function to test each element for a condition; the second parameter of the function represents the index of the source element.
      - returns: An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.
      */
+    @available(*, deprecated, message: "Please use enumerated().takeWhile().map()")
     public func takeWhileWithIndex(_ predicate: @escaping (E, Int) throws -> Bool) -> Observable<E> {
         return enumerated().takeWhile { try predicate($0.element, $0.index) }.map { $0.element }
     }
@@ -107,11 +103,11 @@ extension ObservableType {
 extension Disposable {
     /// Deprecated in favor of `disposed(by:)`
     ///
-    /// **@available(\*, deprecated, message="use disposed(by:) instead")**
     ///
     /// Adds `self` to `bag`.
     ///
     /// - parameter bag: `DisposeBag` to add `self` to.
+    @available(*, deprecated, message: "use disposed(by:) instead", renamed: "disposed(by:)")
     public func addDisposableTo(_ bag: DisposeBag) {
         disposed(by: bag)
     }

Sources/AllTestz/main.swift

@@ -243,9 +243,6 @@ final class ObservableSkipWhileTest_ : ObservableSkipWhileTest, RxTestCase {
     ("testSkipWhile_Dispose_After", ObservableSkipWhileTest.testSkipWhile_Dispose_After),
     ("testSkipWhile_Zero", ObservableSkipWhileTest.testSkipWhile_Zero),
     ("testSkipWhile_Throw", ObservableSkipWhileTest.testSkipWhile_Throw),
-    ("testSkipWhile_Index", ObservableSkipWhileTest.testSkipWhile_Index),
-    ("testSkipWhile_Index_Throw", ObservableSkipWhileTest.testSkipWhile_Index_Throw),
-    ("testSkipWhile_Index_SelectorThrows", ObservableSkipWhileTest.testSkipWhile_Index_SelectorThrows),
     ] }
 }
 
@@ -556,14 +553,6 @@ final class ObservableMapTest_ : ObservableMapTest, RxTestCase {
     ("testMap_Error", ObservableMapTest.testMap_Error),
     ("testMap_Dispose", ObservableMapTest.testMap_Dispose),
     ("testMap_SelectorThrows", ObservableMapTest.testMap_SelectorThrows),
-    ("testMap1_Never", ObservableMapTest.testMap1_Never),
-    ("testMap1_Empty", ObservableMapTest.testMap1_Empty),
-    ("testMap1_Range", ObservableMapTest.testMap1_Range),
-    ("testMap1_Error", ObservableMapTest.testMap1_Error),
-    ("testMap1_Dispose", ObservableMapTest.testMap1_Dispose),
-    ("testMap1_SelectorThrows", ObservableMapTest.testMap1_SelectorThrows),
-    ("testMap_DisposeOnCompleted", ObservableMapTest.testMap_DisposeOnCompleted),
-    ("testMap1_DisposeOnCompleted", ObservableMapTest.testMap1_DisposeOnCompleted),
     ("testMapCompose_Never", ObservableMapTest.testMapCompose_Never),
     ("testMapCompose_Empty", ObservableMapTest.testMapCompose_Empty),
     ("testMapCompose_Range", ObservableMapTest.testMapCompose_Range),
@@ -1037,10 +1026,6 @@ final class ObservableTakeWhileTest_ : ObservableTakeWhileTest, RxTestCase {
     ("testTakeWhile_Dispose_After", ObservableTakeWhileTest.testTakeWhile_Dispose_After),
     ("testTakeWhile_Zero", ObservableTakeWhileTest.testTakeWhile_Zero),
     ("testTakeWhile_Throw", ObservableTakeWhileTest.testTakeWhile_Throw),
-    ("testTakeWhile_Index1", ObservableTakeWhileTest.testTakeWhile_Index1),
-    ("testTakeWhile_Index2", ObservableTakeWhileTest.testTakeWhile_Index2),
-    ("testTakeWhile_Index_Error", ObservableTakeWhileTest.testTakeWhile_Index_Error),
-    ("testTakeWhile_Index_SelectorThrows", ObservableTakeWhileTest.testTakeWhile_Index_SelectorThrows),
     ] }
 }
 
@@ -1869,15 +1854,6 @@ final class ObservableMergeTest_ : ObservableMergeTest, RxTestCase {
     ("testFlatMap_Dispose", ObservableMergeTest.testFlatMap_Dispose),
     ("testFlatMap_SelectorThrows", ObservableMergeTest.testFlatMap_SelectorThrows),
     ("testFlatMap_UseFunction", ObservableMergeTest.testFlatMap_UseFunction),
-    ("testFlatMapIndex_Index", ObservableMergeTest.testFlatMapIndex_Index),
-    ("testFlatMapWithIndex_Complete", ObservableMergeTest.testFlatMapWithIndex_Complete),
-    ("testFlatMapWithIndex_Complete_InnerNotComplete", ObservableMergeTest.testFlatMapWithIndex_Complete_InnerNotComplete),
-    ("testFlatMapWithIndex_Complete_OuterNotComplete", ObservableMergeTest.testFlatMapWithIndex_Complete_OuterNotComplete),
-    ("testFlatMapWithIndex_Complete_ErrorOuter", ObservableMergeTest.testFlatMapWithIndex_Complete_ErrorOuter),
-    ("testFlatMapWithIndex_Error_Inner", ObservableMergeTest.testFlatMapWithIndex_Error_Inner),
-    ("testFlatMapWithIndex_Dispose", ObservableMergeTest.testFlatMapWithIndex_Dispose),
-    ("testFlatMapWithIndex_SelectorThrows", ObservableMergeTest.testFlatMapWithIndex_SelectorThrows),
-    ("testFlatMapWithIndex_UseFunction", ObservableMergeTest.testFlatMapWithIndex_UseFunction),
     ("testConcatMap_InnerCompleteFasterThanOuterElementsAreProduced", ObservableMergeTest.testConcatMap_InnerCompleteFasterThanOuterElementsAreProduced),
     ("testConcatMap_Disposed", ObservableMergeTest.testConcatMap_Disposed),
     ("testConcatMap_OuterComplete_InnerNotComplete", ObservableMergeTest.testConcatMap_OuterComplete_InnerNotComplete),

Tests/RxSwiftTests/Anomalies.swift

@@ -43,7 +43,7 @@ extension AnomaliesTest {
                             return makeSequence(label: "nested", period: 0.02).map { (index, $0) }
                         }
                         .take(10)
-                        .mapWithIndex { ($1, $0.0, $0.1) }
+                        .enumerated().map { ($0, $1.0, $1.1) }
                         .subscribe(
                             onNext: { _ in },
                             onCompleted: {

Tests/RxSwiftTests/Observable+MapTests.swift

@@ -172,185 +172,6 @@ extension ObservableMapTest {
         XCTAssertEqual(res.events, correctMessages)
         XCTAssertEqual(xs.subscriptions, correctSubscriptions)
     }
-    
-    func testMap1_Never() {
-        let scheduler = TestScheduler(initialClock: 0)
-        
-        let xs = scheduler.createHotObservable([
-            next(150, 1),
-            ])
-        
-        let res = scheduler.start { xs.mapWithIndex { ($0 + $1) * 2 } }
-        
-        let correctMessages: [Recorded<Event<Int>>] = [
-        ]
-        
-        let correctSubscriptions = [
-            Subscription(200, 1000)
-        ]
-        
-        XCTAssertEqual(res.events, correctMessages)
-        XCTAssertEqual(xs.subscriptions, correctSubscriptions)
-    }
-    
-    func testMap1_Empty() {
-        let scheduler = TestScheduler(initialClock: 0)
-        
-        let xs = scheduler.createHotObservable([
-            next(150, 1),
-            completed(300)
-            ])
-        
-        let res = scheduler.start { xs.mapWithIndex { ($0 + $1) * 2 } }
-        
-        let correctMessages = [
-            completed(300, Int.self)
-        ]
-        
-        let correctSubscriptions = [
-            Subscription(200, 300)
-        ]
-        
-        XCTAssertEqual(res.events, correctMessages)
-        XCTAssertEqual(xs.subscriptions, correctSubscriptions)
-    }
-    
-    func testMap1_Range() {
-        let scheduler = TestScheduler(initialClock: 0)
-        
-        let xs = scheduler.createHotObservable([
-            next(150, 1),
-            next(210, 5),
-            next(220, 6),
-            next(230, 7),
-            next(240, 8),
-            completed(300)
-            ])
-        
-        let res = scheduler.start { xs.mapWithIndex { ($0 + $1) * 2 } }
-        
-        let correctMessages = [
-            next(210, (5 + 0) * 2),
-            next(220, (6 + 1) * 2),
-            next(230, (7 + 2) * 2),
-            next(240, (8 + 3) * 2),
-            completed(300)
-        ]
-        
-        let correctSubscriptions = [
-            Subscription(200, 300)
-        ]
-        
-        XCTAssertEqual(res.events, correctMessages)
-        XCTAssertEqual(xs.subscriptions, correctSubscriptions)
-    }
-    
-    func testMap1_Error() {
-        let scheduler = TestScheduler(initialClock: 0)
-        
-        let xs = scheduler.createHotObservable([
-            next(150, 1),
-            next(210, 5),
-            next(220, 6),
-            next(230, 7),
-            next(240, 8),
-            error(300, testError)
-            ])
-        
-        let res = scheduler.start { xs.mapWithIndex { ($0 + $1) * 2 }  }
-        
-        let correctMessages = [
-            next(210, (5 + 0) * 2),
-            next(220, (6 + 1) * 2),
-            next(230, (7 + 2) * 2),
-            next(240, (8 + 3) * 2),
-            error(300, testError)
-        ]
-        
-        let correctSubscriptions = [
-            Subscription(200, 300)
-        ]
-        
-        XCTAssertEqual(res.events, correctMessages)
-        XCTAssertEqual(xs.subscriptions, correctSubscriptions)
-    }
-    
-    func testMap1_Dispose() {
-        let scheduler = TestScheduler(initialClock: 0)
-        
-        let xs = scheduler.createHotObservable([
-            next(150, 1),
-            next(210, 5),
-            next(220, 6),
-            next(230, 7),
-            next(240, 8),
-            error(300, testError)
-            ])
-        
-        let res = scheduler.start(disposed: 290) { xs.mapWithIndex { ($0 + $1) * 2 } }
-        
-        let correctMessages = [
-            next(210, (5 + 0) * 2),
-            next(220, (6 + 1) * 2),
-            next(230, (7 + 2) * 2),
-            next(240, (8 + 3) * 2),
-        ]
-        
-        let correctSubscriptions = [
-            Subscription(200, 290)
-        ]
-        
-        XCTAssertEqual(res.events, correctMessages)
-        XCTAssertEqual(xs.subscriptions, correctSubscriptions)
-    }
-    
-    func testMap1_SelectorThrows() {
-        let scheduler = TestScheduler(initialClock: 0)
-        
-        let xs = scheduler.createHotObservable([
-            next(150, 1),
-            next(210, 5),
-            next(220, 6),
-            next(230, 7),
-            next(240, 8),
-            error(300, testError)
-            ])
-        
-        let res = scheduler.start { xs.mapWithIndex { x, i throws -> Int in if x < 7 { return ((x + i) * 2) } else { throw testError } } }
-        
-        let correctMessages = [
-            next(210, (5 + 0) * 2),
-            next(220, (6 + 1) * 2),
-            error(230, testError)
-        ]
-        
-        let correctSubscriptions = [
-            Subscription(200, 230)
-        ]
-        
-        XCTAssertEqual(res.events, correctMessages)
-        XCTAssertEqual(xs.subscriptions, correctSubscriptions)
-    }
-    
-    func testMap_DisposeOnCompleted() {
-        _ = Observable.just("A")
-            .map { a in
-                return a
-            }
-            .subscribe(onNext: { _ in
-                
-            })
-    }
-    
-    func testMap1_DisposeOnCompleted() {
-        _ = Observable.just("A")
-            .mapWithIndex { (a, i) in
-                return a
-            }
-            .subscribe(onNext: { _ in
-                
-            })
-    }
 
     #if TRACE_RESOURCES
         func testMapReleasesResourcesOnComplete() {
@@ -364,18 +185,6 @@ extension ObservableMapTest {
         func testMap2ReleasesResourcesOnError() {
             _ = Observable<Int>.just(1).map { _ -> Bool in throw testError }.subscribe()
         }
-
-        func testMapWithIndexReleasesResourcesOnComplete() {
-            _ = Observable<Int>.just(1).mapWithIndex { _, _ in true }.subscribe()
-        }
-
-        func testMapWithIndex1ReleasesResourcesOnError() {
-            _ = Observable<Int>.error(testError).mapWithIndex { _, _ in true }.subscribe()
-        }
-
-        func testMapWithIndex2ReleasesResourcesOnError() {
-            _ = Observable<Int>.just(1).mapWithIndex { _, _ -> Bool in throw testError }.subscribe()
-        }
     #endif
 }