New integer protocols

benchmark/single-source/ByteSwap.swift

@@ -18,14 +18,15 @@ import TestsUtils
 
 // a naive O(n) implementation of byteswap.
 func byteswap_n(_ a: UInt64) -> UInt64 {
-  return ((a & 0x00000000000000FF) << 56) |
-      ((a & 0x000000000000FF00) << 40) |
-      ((a & 0x0000000000FF0000) << 24) |
-      ((a & 0x00000000FF000000) <<  8) |
-      ((a & 0x000000FF00000000) >>  8) |
-      ((a & 0x0000FF0000000000) >> 24) |
-      ((a & 0x00FF000000000000) >> 40) |
-      ((a & 0xFF00000000000000) >> 56)
+  var result = ((a & 0x00000000000000FF) << 56)
+  result |=    ((a & 0x000000000000FF00) << 40)
+  result |=    ((a & 0x0000000000FF0000) << 24)
+  result |=    ((a & 0x00000000FF000000) <<  8)
+  result |=    ((a & 0x000000FF00000000) >>  8)
+  result |=    ((a & 0x0000FF0000000000) >> 24)
+  result |=    ((a & 0x00FF000000000000) >> 40)
+  result |=    ((a & 0xFF00000000000000) >> 56)
+  return result
 }
 
 // a O(logn) implementation of byteswap.

stdlib/private/StdlibCollectionUnittest/CheckCollectionInstance.swift.gyb

@@ -102,7 +102,7 @@ internal func _checkIncrementalAdvance<Instances, BaseCollection>(
       -baseCollection.distance(from: limit, to: i)
 
     var offset: BaseCollection.IndexDistance = 0
-    for _ in 0...(d * sign).toIntMax() {
+    for _ in 0...Int64(d * sign) {
       let j = baseCollection.index(i, offsetBy: offset)
       let k = baseCollection.index(i, offsetBy: offset + sign, limitedBy: limit) ?? limit
       let jAtLimit = offset == d
@@ -447,8 +447,7 @@ public func checkOneLevelOf${Traversal}Collection<
   let expectedArray = Array(expected)
 
   // Check `count`.
-  expectEqual(
-    expectedArray.count.toIntMax(), collection.count.toIntMax(), ${trace})
+  expectEqual(Int64(expectedArray.count), Int64(collection.count), ${trace})
 
   //===------------------------------------------------------------------===//
   // Check Iteration behavior.

stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift

@@ -790,10 +790,14 @@ public let mapTests = [
     [], [],
     { _ -> Int32 in expectUnreachable(); return 0xffff }),
 
-  MapTest([ 101 ], [ 1 ], { (x: Int) -> Int32 in Int32(x + 100) }),
-  MapTest([ 101, 102 ], [ 1, 2 ], { (x: Int) -> Int32 in Int32(x + 100) }),
-  MapTest([ 101, 102, 103 ], [ 1, 2, 3 ], { (x: Int) -> Int32 in Int32(x + 100) }),
-  MapTest(Array(101..<200), Array(1..<100), { (x: Int) -> Int32 in Int32(x + 100) }),
+  MapTest([ 101 ], [ 1 ],
+    { (x: Int) -> Int32 in Int32(x + 100) }),
+  MapTest([ 101, 102 ], [ 1, 2 ],
+    { (x: Int) -> Int32 in Int32(x + 100) }),
+  MapTest([ 101, 102, 103 ], [ 1, 2, 3 ],
+    { (x: Int) -> Int32 in Int32(x + 100) }),
+  MapTest(Array(101..<200), Array(1..<100),
+    { (x: Int) -> Int32 in Int32(x + 100) }),
 ]
 
 public let minMaxTests = [

stdlib/private/StdlibUnicodeUnittest/Collation.swift

@@ -338,13 +338,13 @@ public struct StringComparisonTest {
 
 public func sortKey(forCollationElements ces: [UInt64]) -> ([UInt16], [UInt16], [UInt16]) {
   func L1(_ ce: UInt64) -> UInt16 {
-    return UInt16(truncatingBitPattern: ce >> 32)
+    return UInt16(extendingOrTruncating: ce &>> 32)
   }
   func L2(_ ce: UInt64) -> UInt16 {
-    return UInt16(truncatingBitPattern: ce >> 16)
+    return UInt16(extendingOrTruncating: ce &>> 16)
   }
   func L3(_ ce: UInt64) -> UInt16 {
-    return UInt16(truncatingBitPattern: ce)
+    return UInt16(extendingOrTruncating: ce)
   }
 
   var result1: [UInt16] = []

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -2447,7 +2447,7 @@ public func expectEqualsUnordered<
 public func expectEqualsUnordered<T : Strideable>(
   _ expected: CountableRange<T>, _ actual: [T], ${TRACE}
 ) {
-  if numericCast(expected.count) != actual.count {
+  if expected.count != actual.count {
     expectationFailure("expected elements: \"\(expected)\"\n"
       + "actual: \"\(actual)\" (of type \(String(reflecting: type(of: actual))))",
       trace: ${trace})

stdlib/private/SwiftPrivate/ShardedAtomicCounter.swift

@@ -72,7 +72,7 @@ public struct _stdlib_ShardedAtomicCounter {
 
     public mutating func randomInt() -> Int {
       var result = 0
-      for _ in 0..<Int._sizeInBits {
+      for _ in 0..<Int.bitWidth {
         result = (result << 1) | (_state & 1)
         _state = (_state >> 1) ^ (-(_state & 1) & Int(bitPattern: 0xD0000001))
       }

stdlib/private/SwiftPrivate/SwiftPrivate.swift

@@ -13,14 +13,17 @@
 import SwiftShims
 
 /// Convert the given numeric value to a hexadecimal string.
-public func asHex<T : Integer>(_ x: T) -> String {
-  return "0x" + String(x.toIntMax(), radix: 16)
+  // FIXME(integers): support a more general BinaryInteger protocol
+public func asHex<T : FixedWidthInteger>(_ x: T) -> String {
+  return "0x" + String(x, radix: 16)
 }
 
 /// Convert the given sequence of numeric values to a string representing
 /// their hexadecimal values.
-public func asHex<S: Sequence>(_ x: S) -> String
-  where S.Iterator.Element : Integer {
+  // FIXME(integers): support a more general BinaryInteger protocol
+public func asHex<S : Sequence>(_ x: S) -> String
+  where
+  S.Iterator.Element : FixedWidthInteger {
   return "[ " + x.lazy.map { asHex($0) }.joined(separator: ", ") + " ]"
 }
 

stdlib/public/Platform/tgmath.swift.gyb

@@ -12,8 +12,9 @@
 
 // Generic functions implementable directly on FloatingPoint.
 @_transparent
-public func fabs<T: FloatingPoint>(_ x: T) -> T {
-  return abs(x)
+public func fabs<T: FloatingPoint>(_ x: T) -> T
+  where T.Magnitude == T {
+  return x.magnitude
 }
 
 @_transparent

stdlib/public/SDK/CoreGraphics/CGFloat.swift.gyb

@@ -67,6 +67,19 @@ public struct CGFloat {
   public var native: NativeType
 }
 
+extension CGFloat : SignedNumeric {
+  // FIXME(integers): implement properly
+  public init?<T : BinaryInteger>(exactly source: T) {
+    fatalError()
+  }
+
+  @_transparent
+  public var magnitude: CGFloat {
+    return CGFloat(Swift.abs(native))
+  }
+
+}
+
 extension CGFloat : BinaryFloatingPoint {
 
   public typealias RawSignificand = UInt
@@ -196,34 +209,28 @@ extension CGFloat : BinaryFloatingPoint {
     return CGFloat(native.nextUp)
   }
 
-  @_transparent
-  public var magnitude: CGFloat {
-    return CGFloat(Swift.abs(native))
-  }
-
-  @_transparent
   public mutating func negate() {
     native.negate()
   }
 
   @_transparent
-  public mutating func add(_ other: CGFloat) {
-    native.add(other.native)
+  public static func +=(_ lhs: inout CGFloat, _ rhs: CGFloat) {
+    lhs.native += rhs.native
   }
 
   @_transparent
-  public mutating func subtract(_ other: CGFloat) {
-    native.subtract(other.native)
+  public static func -=(_ lhs: inout CGFloat, _ rhs: CGFloat) {
+    lhs.native -= rhs.native
   }
 
   @_transparent
-  public mutating func multiply(by other: CGFloat) {
-    native.multiply(by: other.native)
+  public static func *=(_ lhs: inout CGFloat, _ rhs: CGFloat) {
+    lhs.native *= rhs.native
   }
 
   @_transparent
-  public mutating func divide(by other: CGFloat) {
-    native.divide(by: other.native)
+  public static func /=(_ lhs: inout CGFloat, _ rhs: CGFloat) {
+    lhs.native /= rhs.native
   }
 
   @_transparent
@@ -418,44 +425,34 @@ extension Float {
 //  tweaking the overload resolution rules, or by removing the other
 //  definitions in the standard lib, or both.
 
-@_transparent
-public func +(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
-  return lhs.adding(rhs)
-}
-
-@_transparent
-public func -(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
-  return lhs.subtracting(rhs)
-}
-
-@_transparent
-public func *(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
-  return lhs.multiplied(by: rhs)
-}
-
-@_transparent
-public func /(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
-  return lhs.divided(by: rhs)
-}
-
-@_transparent
-public func +=(lhs: inout CGFloat, rhs: CGFloat) {
-  lhs.add(rhs)
-}
+extension CGFloat {
+  @_transparent
+  public static func +(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
+    var lhs = lhs
+    lhs += rhs
+    return lhs
+  }
 
-@_transparent
-public func -=(lhs: inout CGFloat, rhs: CGFloat) {
-  lhs.subtract(rhs)
-}
+  @_transparent
+  public static func -(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
+    var lhs = lhs
+    lhs -= rhs
+    return lhs
+  }
 
-@_transparent
-public func *=(lhs: inout CGFloat, rhs: CGFloat) {
-  lhs.multiply(by: rhs)
-}
+  @_transparent
+  public static func *(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
+    var lhs = lhs
+    lhs *= rhs
+    return lhs
+  }
 
-@_transparent
-public func /=(lhs: inout CGFloat, rhs: CGFloat) {
-  lhs.divide(by: rhs)
+  @_transparent
+  public static func /(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
+    var lhs = lhs
+    lhs /= rhs
+    return lhs
+  }
 }
 
 //===----------------------------------------------------------------------===//

stdlib/public/SDK/Dispatch/Time.swift

@@ -69,12 +69,14 @@ public struct DispatchTime : Comparable {
 	}
 }
 
-public func <(a: DispatchTime, b: DispatchTime) -> Bool {
-	return a.rawValue < b.rawValue
-}
-
-public func ==(a: DispatchTime, b: DispatchTime) -> Bool {
-	return a.rawValue == b.rawValue
+extension DispatchTime {
+  public static func < (a: DispatchTime, b: DispatchTime) -> Bool {
+    return a.rawValue < b.rawValue
+  }
+
+  public static func ==(a: DispatchTime, b: DispatchTime) -> Bool {
+    return a.rawValue == b.rawValue
+  }
 }
 
 public struct DispatchWallTime : Comparable {
@@ -96,17 +98,20 @@ public struct DispatchWallTime : Comparable {
 	}
 }
 
-public func <(a: DispatchWallTime, b: DispatchWallTime) -> Bool {
-	if b.rawValue == ~0 {
-		return a.rawValue != ~0
-	} else if a.rawValue == ~0 {
-		return false
-	}
-	return -Int64(bitPattern: a.rawValue) < -Int64(bitPattern: b.rawValue)
-}
-
-public func ==(a: DispatchWallTime, b: DispatchWallTime) -> Bool {
-	return a.rawValue == b.rawValue
+extension DispatchWallTime {
+  public static func <(a: DispatchWallTime, b: DispatchWallTime) -> Bool {
+    let negativeOne: dispatch_time_t = ~0
+    if b.rawValue == negativeOne {
+      return a.rawValue != negativeOne
+    } else if a.rawValue == negativeOne {
+      return false
+    }
+    return -Int64(bitPattern: a.rawValue) < -Int64(bitPattern: b.rawValue)
+  }
+
+  public static func ==(a: DispatchWallTime, b: DispatchWallTime) -> Bool {
+    return a.rawValue == b.rawValue
+  }
 }
 
 public enum DispatchTimeInterval {

stdlib/public/SDK/Foundation/AffineTransform.swift

@@ -273,7 +273,13 @@ public struct AffineTransform : ReferenceConvertible, Hashable, CustomStringConv
     }
 
     public var hashValue : Int {
-        return Int(m11 + m12 + m21 + m22 + tX + tY)
+        // FIXME(integers): the expression was broken into pieces to speed up
+        // compilation.
+        // Used to be just: return Int(m11 + m12 + m21 + m22 + tX + tY)
+        let a: CGFloat = m11 + m12
+        let b: CGFloat = m21 + m22
+        let c: CGFloat = tX + tY
+        return Int(a + b + c)
     }
 
     public var description: String {