[swift-4.0-branch][stdlib] Removing < overloads (#9343)

* [stdlib] Removing a few harmful overloads of <

At some point during the implementation of integer protocols these
overloads were necessary to make expressions like `i32 < 0` be faster
and unambiguous.
Now they are no longer necessary, and also cause problems for
expressions like `(u64 - u64) < u64`, where they cause the deprecated
`func - (Strideable, Strideable) -> Stride` be used, which is wrong, as
it will trap in many cases, where `func - (UInt64, UInt64) -> UInt64`
would not.

Fixes: <rdar://problem/31909031>

* Adding tests for the removed < overloads

* [stdlib] Addressing the benchmark regression

Author: moiseev

stdlib/public/core/Integers.swift.gyb

@@ -2640,80 +2640,6 @@ public struct ${Self}
     return Bool(Builtin.cmp_${u}lt_Int${bits}(lhs._value, rhs._value))
   }
 
-// FIXME(integers): it should be possible to turn this into an optimizer pass
-%   if Self != 'Int':
-  @_transparent
-  public static func < (lhs: ${Self}, rhs: Int) -> Bool {
-%     if not signed:
-    if rhs < 0 { return false }
-%     end
-
-%     if bits < word_bits:
-    let lhs_ = Int(_truncatingBits: lhs._lowUWord)
-    return lhs_ < rhs
-%     elif bits == word_bits:
-    return Bool(Builtin.cmp_${u}lt_Int${bits}(lhs._value, rhs._value))
-%     else:
-    let rhs_ = ${Self}(_truncatingBits: rhs._lowUWord)
-    return lhs < rhs_
-%     end
-  }
-
-  @_transparent
-  public static func < (lhs: Int, rhs: ${Self}) -> Bool {
-%     if not signed:
-    if lhs < 0 { return true }
-%     end
-%     if bits < word_bits:
-    let rhs_ = Int(_truncatingBits: rhs._lowUWord)
-    return lhs < rhs_
-%     elif bits == word_bits:
-    return Bool(Builtin.cmp_${u}lt_Int${bits}(lhs._value, rhs._value))
-%     else:
-    let lhs_ = ${Self}(_truncatingBits: lhs._lowUWord)
-    return lhs_ < rhs
-%     end
-  }
-
-%     for Args in ['lhs: %s, rhs: Int' % Self, 'lhs: Int, rhs: %s' % Self]:
-  @_transparent
-  public static func > (${Args}) -> Bool {
-    return rhs < lhs
-  }
-
-  @_transparent
-  public static func <= (${Args}) -> Bool {
-    return !(rhs < lhs)
-  }
-
-  @_transparent
-  public static func >= (${Args}) -> Bool {
-    return !(lhs < rhs)
-  }
-
-%     end
-
-%   else: # if Self != 'Int'
-
-  // FIXME(integers): Comparable default implementations should really be
-  // chosen by the compiler. <rdar://problem/29340480>
-  @_transparent
-  public static func > (lhs: Int, rhs: Int) -> Bool {
-    return rhs < lhs
-  }
-
-  @_transparent
-  public static func <= (lhs: Int, rhs: Int) -> Bool {
-    return !(rhs < lhs)
-  }
-
-  @_transparent
-  public static func >= (lhs: Int, rhs: Int) -> Bool {
-    return !(lhs < rhs)
-  }
-
-%   end # if Self != 'Int'
-
 // FIXME(integers): pending compiler improvements.
 // Basically, most simple arithmetic expressions become too complex when `+`
 // gets defined on the protocol rather than on concrete type.

stdlib/public/core/StringComparable.swift

@@ -120,6 +120,7 @@ extension String {
 }
 
 extension String : Equatable {
+  @inline(__always)
   public static func == (lhs: String, rhs: String) -> Bool {
 #if _runtime(_ObjC)
     // We only want to perform this optimization on objc runtimes. Elsewhere,

test/stdlib/MixedTypeArithmeticsDiagnostics3.swift

@@ -33,3 +33,9 @@ func mixedTypeArithemtics() {
     x += (42 as Int)
   }
 }
+
+func radar31909031() {
+  let x = UInt64()
+  let y = UInt64()
+  _ = (x - y) < UInt64(42) // should not produce a mixed-type warning
+}

test/stdlib/MixedTypeArithmeticsDiagnostics4.swift

@@ -33,3 +33,9 @@ func mixedTypeArithemtics() {
     x += (42 as Int)
   }
 }
+
+func radar31909031() {
+  let x = UInt64()
+  let y = UInt64()
+  _ = (x - y) < UInt64(42) // should not produce a mixed-type warning
+}