[stdlib] Remove optional comparison operators (SE-0121)

stdlib/public/core/Optional.swift

@@ -380,44 +380,6 @@ public func != <T>(lhs: _OptionalNilComparisonType, rhs: T?) -> Bool {
   }
 }
 
-public func < <T : Comparable>(lhs: T?, rhs: T?) -> Bool {
-  switch (lhs, rhs) {
-  case let (l?, r?):
-    return l < r
-  case (nil, _?):
-    return true
-  default:
-    return false
-  }
-}
-
-public func > <T : Comparable>(lhs: T?, rhs: T?) -> Bool {
-  switch (lhs, rhs) {
-  case let (l?, r?):
-    return l > r
-  default:
-    return rhs < lhs
-  }
-}
-
-public func <= <T : Comparable>(lhs: T?, rhs: T?) -> Bool {
-  switch (lhs, rhs) {
-  case let (l?, r?):
-    return l <= r
-  default:
-    return !(rhs < lhs)
-  }
-}
-
-public func >= <T : Comparable>(lhs: T?, rhs: T?) -> Bool {
-  switch (lhs, rhs) {
-  case let (l?, r?):
-    return l >= r
-  default:
-    return !(lhs < rhs)
-  }
-}
-
 /// Performs a nil-coalescing operation, returning the wrapped value of an
 /// `Optional` instance or a default value.
 ///

test/1_stdlib/Optional.swift

@@ -73,7 +73,6 @@ func testRelation(_ p: (Int?, Int?) -> Bool) -> [Bool] {
 OptionalTests.test("Equatable") {
   expectEqual([true, false, false, false, false, true], testRelation(==))
   expectEqual([false, true, true, true, true, false], testRelation(!=))
-  expectEqual([false, true, false, false, true, false], testRelation(<))
 }
 
 OptionalTests.test("CustomReflectable") {

test/1_stdlib/TestCalendar.swift

@@ -219,7 +219,7 @@ class TestCalendar : TestCalendarSuper {
             // Find the days numbered '31' after 'd', allowing the algorithm to move to the next day if required
             c.enumerateDates(startingAfter: d, matching: DateComponents(day: 31), matchingPolicy: .nextTime) { result, exact, stop in
                 // Just stop some arbitrary time in the future
-                if result > d + 86400*365 { stop = true }
+                if result! > d + 86400*365 { stop = true }
                 count += 1
                 if exact { exactCount += 1 }
             }

test/Constraints/diagnostics.swift

@@ -787,15 +787,14 @@ func nilComparison(i: Int, o: AnyObject) {
   _ = i != nil // expected-warning {{comparing non-optional value of type 'Int' to nil always returns true}}
   _ = nil != i // expected-warning {{comparing non-optional value of type 'Int' to nil always returns true}}
 
-  // These should all be illegal when SE-0121 lands.
-  _ = i < nil
-  _ = nil < i
-  _ = i <= nil
-  _ = nil <= i
-  _ = i > nil
-  _ = nil > i
-  _ = i >= nil
-  _ = nil >= i
+  _ = i < nil  // expected-error {{type 'Int' is not optional, value can never be nil}}
+  _ = nil < i  // expected-error {{type 'Int' is not optional, value can never be nil}}
+  _ = i <= nil // expected-error {{type 'Int' is not optional, value can never be nil}}
+  _ = nil <= i // expected-error {{type 'Int' is not optional, value can never be nil}}
+  _ = i > nil  // expected-error {{type 'Int' is not optional, value can never be nil}}
+  _ = nil > i  // expected-error {{type 'Int' is not optional, value can never be nil}}
+  _ = i >= nil // expected-error {{type 'Int' is not optional, value can never be nil}}
+  _ = nil >= i // expected-error {{type 'Int' is not optional, value can never be nil}}
 
   _ = o === nil // expected-warning {{comparing non-optional value of type 'AnyObject' to nil always returns false}}
   _ = o !== nil // expected-warning {{comparing non-optional value of type 'AnyObject' to nil always returns true}}

test/Parse/try.swift

@@ -42,10 +42,10 @@ i = try? foo() + bar()
 i ?+= try? foo() + bar()
 i ?+= try? foo() %%%% bar() // expected-error {{'try?' following assignment operator does not cover everything to its right}} // expected-error {{call can throw but is not marked with 'try'}} // expected-warning {{result of operator '%%%%' is unused}}
 i ?+= try? foo() %%% bar()
-_ = foo() < try? bar() // expected-error {{'try?' cannot appear to the right of a non-assignment operator}} // expected-error {{call can throw but is not marked with 'try'}}
-_ = (try? foo()) < bar() // expected-error {{call can throw but is not marked with 'try'}}
-_ = foo() < (try? bar()) // expected-error {{call can throw but is not marked with 'try'}}
-_ = (try? foo()) < (try? bar())
+_ = foo() == try? bar() // expected-error {{'try?' cannot appear to the right of a non-assignment operator}} // expected-error {{call can throw but is not marked with 'try'}}
+_ = (try? foo()) == bar() // expected-error {{call can throw but is not marked with 'try'}}
+_ = foo() == (try? bar()) // expected-error {{call can throw but is not marked with 'try'}}
+_ = (try? foo()) == (try? bar())
 
 let j = true ? try? foo() : try? bar() + 0
 let k = true ? try? foo() : try? bar() %%% 0 // expected-error {{'try?' following conditional operator does not cover everything to its right}}