Merge pull request #951 from moiseev/new-integer-protocols

Upgrading to the new integer protocols

Author: slavapestov

Foundation/CGFloat.swift

@@ -145,6 +145,19 @@ public struct CGFloat {
     public var native: NativeType
 }
 
+extension CGFloat : SignedNumeric {
+    // FIXME(integers): implement
+    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
@@ -278,34 +291,29 @@ 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
@@ -564,45 +572,36 @@ 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)
-}
+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.add(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.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)
-}
 
 //===----------------------------------------------------------------------===//
 // Strideable Conformance

Foundation/NSDecimal.swift

@@ -166,25 +166,6 @@ extension Decimal {
         if !self.isFinite { return Decimal.nan }
         return Decimal(_exponent: _exponent, _length: 8, _isNegative: 0, _isCompact: 1, _reserved: 0, _mantissa: (0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000))
     }
-    public mutating func add(_ other: Decimal) {
-        var rhs = other
-        _ = NSDecimalAdd(&self, &self, &rhs, .plain)
-    }
-    public mutating func subtract(_ other: Decimal) {
-        var rhs = other
-        _ = NSDecimalSubtract(&self, &self, &rhs, .plain)
-    }
-    public mutating func multiply(by other: Decimal) {
-        var rhs = other
-        _ = NSDecimalMultiply(&self, &self, &rhs, .plain)
-    }
-    public mutating func divide(by other: Decimal) {
-        var rhs = other
-        _ = NSDecimalDivide(&self, &self, &rhs, .plain)
-    }
-    public mutating func negate() {
-        _isNegative = _isNegative == 0 ? 1 : 0
-    }
     public func isEqual(to other: Decimal) -> Bool {
         return self.compare(to: other) == .orderedSame
     }
@@ -216,26 +197,6 @@ extension Decimal {
     public var nextDown: Decimal {
         return self - Decimal(_exponent: _exponent, _length: 1, _isNegative: 0, _isCompact: 1, _reserved: 0, _mantissa: (0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000))
     }
-    public static func +(lhs: Decimal, rhs: Decimal) -> Decimal {
-        var answer = lhs
-        answer.add(rhs)
-        return answer;
-    }
-    public static func -(lhs: Decimal, rhs: Decimal) -> Decimal {
-        var answer = lhs
-        answer.subtract(rhs)
-        return answer;
-    }
-    public static func /(lhs: Decimal, rhs: Decimal) -> Decimal {
-        var answer = lhs
-        answer.divide(by: rhs)
-        return answer;
-    }
-    public static func *(lhs: Decimal, rhs: Decimal) -> Decimal {
-        var answer = lhs
-        answer.multiply(by: rhs)
-        return answer;
-    }
 }
 
 extension Decimal : Hashable, Comparable {
@@ -320,7 +281,63 @@ extension Decimal : ExpressibleByIntegerLiteral {
     }
 }
 
-extension Decimal : SignedNumber {
+extension Decimal : SignedNumeric {
+    public var magnitude: Decimal {
+        return Decimal(_exponent: _exponent, _length: _length, _isNegative: 0, _isCompact: _isCompact, _reserved: 0, _mantissa: _mantissa)
+    }
+
+    // FIXME(integers): implement properly
+    public init?<T : BinaryInteger>(exactly source: T) {
+        fatalError()
+    }
+
+    public static func +=(_ lhs: inout Decimal, _ rhs: Decimal) {
+        var rhs = rhs
+        _ = NSDecimalAdd(&lhs, &lhs, &rhs, .plain)
+    }
+
+    public static func -=(_ lhs: inout Decimal, _ rhs: Decimal) {
+        var rhs = rhs
+        _ = NSDecimalSubtract(&lhs, &lhs, &rhs, .plain)
+    }
+
+    public static func *=(_ lhs: inout Decimal, _ rhs: Decimal) {
+        var rhs = rhs
+        _ = NSDecimalMultiply(&lhs, &lhs, &rhs, .plain)
+    }
+
+    public static func /=(_ lhs: inout Decimal, _ rhs: Decimal) {
+        var rhs = rhs
+        _ = NSDecimalDivide(&lhs, &lhs, &rhs, .plain)
+    }
+
+    public static func +(lhs: Decimal, rhs: Decimal) -> Decimal {
+        var answer = lhs
+        answer += rhs
+        return answer;
+    }
+
+    public static func -(lhs: Decimal, rhs: Decimal) -> Decimal {
+        var answer = lhs
+        answer -= rhs
+        return answer;
+    }
+
+    public static func /(lhs: Decimal, rhs: Decimal) -> Decimal {
+        var answer = lhs
+        answer /= rhs
+        return answer;
+    }
+
+    public static func *(lhs: Decimal, rhs: Decimal) -> Decimal {
+        var answer = lhs
+        answer *= rhs
+        return answer;
+    }
+
+    public mutating func negate() {
+        _isNegative = _isNegative == 0 ? 1 : 0
+    }
 }
 
 extension Decimal : Strideable {
@@ -332,12 +349,6 @@ extension Decimal : Strideable {
     }
 }
 
-extension Decimal : AbsoluteValuable {
-    public static func abs(_ x: Decimal) -> Decimal {
-        return Decimal(_exponent: x._exponent, _length: x._length, _isNegative: 0, _isCompact: x._isCompact, _reserved: 0, _mantissa: x._mantissa)
-    }
-}
-
 extension Decimal {
     public typealias RoundingMode = NSDecimalNumber.RoundingMode
     public typealias CalculationError = NSDecimalNumber.CalculationError

Foundation/NSError.swift

@@ -372,13 +372,13 @@ public protocol __BridgedNSError : Error {
 // Allow two bridged NSError types to be compared.
 extension __BridgedNSError where Self: RawRepresentable, Self.RawValue: SignedInteger {
     public static func ==(lhs: Self, rhs: Self) -> Bool {
-        return lhs.rawValue.toIntMax() == rhs.rawValue.toIntMax()
+        return lhs.rawValue == rhs.rawValue
     }
 }
 
 public extension __BridgedNSError where Self: RawRepresentable, Self.RawValue: SignedInteger {
     public var _domain: String { return Self._nsErrorDomain }
-    public var _code: Int { return Int(rawValue.toIntMax()) }
+    public var _code: Int { return Int(rawValue) }
 
     public init?(rawValue: RawValue) {
         self = unsafeBitCast(rawValue, to: Self.self)
@@ -398,14 +398,14 @@ public extension __BridgedNSError where Self: RawRepresentable, Self.RawValue: S
 // Allow two bridged NSError types to be compared.
 extension __BridgedNSError where Self: RawRepresentable, Self.RawValue: UnsignedInteger {
     public static func ==(lhs: Self, rhs: Self) -> Bool {
-        return lhs.rawValue.toUIntMax() == rhs.rawValue.toUIntMax()
+        return lhs.rawValue == rhs.rawValue
     }
 }
 
 public extension __BridgedNSError where Self: RawRepresentable, Self.RawValue: UnsignedInteger {
     public var _domain: String { return Self._nsErrorDomain }
     public var _code: Int {
-        return Int(bitPattern: UInt(rawValue.toUIntMax()))
+        return Int(bitPattern: UInt(rawValue))
     }
 
     public init?(rawValue: RawValue) {

Foundation/NSScanner.swift

@@ -219,7 +219,8 @@ internal protocol _BitShiftable {
     static func <<(lhs: Self, rhs: Self) -> Self
 }
 
-internal protocol _IntegerLike : Integer, _BitShiftable {
+// FIXME(integers): replace this protocol with just a FixedWidthInteger
+internal protocol _IntegerLike : FixedWidthInteger, _BitShiftable {
     init(_ value: Int)
     static var max: Self { get }
     static var min: Self { get }