Compiler Explorer

Source code

// MARK: Bespoke from Int to Int

func bespokeIntInt(n: Int, a: Int) -> Int {
    n.distance(to: a)
}

// MARK: Before

func oldInt64Int64(n: Int64, a: Int64) -> Int64 {
    n.distance1(to: a)
}

func oldInt64Int32(n: Int64, a: Int64) -> Int32 {
    n.distance1(to: a)
}

func oldInt32Int64(n: Int32, a: Int32) -> Int64 {
    n.distance1(to: a)
}

func oldInt32Int32(n: Int32, a: Int32) -> Int32 {
    n.distance1(to: a)
}

func oldUInt64Int64(n: UInt64, a: UInt64) -> Int64 {
    n.distance1(to: a)
}

func oldUInt64Int32(n: UInt64, a: UInt64) -> Int32 {
    n.distance1(to: a)
}

func oldUInt32Int64(n: UInt32, a: UInt32) -> Int64 {
    n.distance1(to: a)
}

func oldUInt32Int32(n: UInt32, a: UInt32) -> Int32 {
    n.distance1(to: a)
}

// MARK: After

func newInt64Int64(n: Int64, a: Int64) -> Int64 {
    n.distance2(to: a)
}

func newInt64Int32(n: Int64, a: Int64) -> Int32 {
    n.distance2(to: a)
}

func newInt32Int64(n: Int32, a: Int32) -> Int64 {
    n.distance2(to: a)
}

func newInt32Int32(n: Int32, a: Int32) -> Int32 {
    n.distance2(to: a)
}

func newUInt64Int64(n: UInt64, a: UInt64) -> Int64 {
    n.distance2(to: a)
}

func newUInt64Int32(n: UInt64, a: UInt64) -> Int32 {
    n.distance2(to: a)
}

func newUInt32Int64(n: UInt32, a: UInt32) -> Int64 {
    n.distance2(to: a)
}

func newUInt32Int32(n: UInt32, a: UInt32) -> Int32 {
    n.distance2(to: a)
}

// MARK: Helpers

@inlinable public func _preconditionFailure(
  _ message: @autoclosure () -> String = String(),
  file: StaticString = #file,
  line: UInt = #line
) -> Never {
  preconditionFailure(message(), file: file, line: line)
}

// MARK: Generic

extension BinaryInteger {
  public func distance1<T>(to other: Self) -> T where T: SignedInteger & FixedWidthInteger {
    typealias Int = T // this enables control-c control-v
  
    if !Self.isSigned {
      if self > other {
        if let result = Int(exactly: self - other) {
          return -result
        }
      } else {
        if let result = Int(exactly: other - self) {
          return result
        }
      }
    } else {
      let isNegative = self < (0 as Self)
      if isNegative == (other < (0 as Self)) {
        if let result = Int(exactly: other - self) {
          return result
        }
      } else {
        if let result = Int(exactly: self.magnitude + other.magnitude) {
          return isNegative ? result : -result
        }
      }
    }
    _preconditionFailure("Distance is not representable in Int")
  }
  
  public func distance2<T>(to other: Self) -> T where T: SignedInteger & FixedWidthInteger {
    typealias Int = T // this enables control-c control-v
  
    if self.bitWidth < Int.bitWidth && other.bitWidth < Int.bitWidth {
      // Smaller integers always fit.
      return Int(truncatingIfNeeded: other) &- Int(truncatingIfNeeded: self)
    } else if Self.isSigned || self <= other {
      // Use trapping subtraction for performance.
      if let result = Int(exactly: other - self) {
        return result
      }
    } else {
      // This type is unsigned and the distance is negative here.
      let absolute = self - other
      let distance = ~Int(truncatingIfNeeded: absolute) &+ 1
      // The zero comparison generates better code in Swift 5.10.
      if absolute.bitWidth <= Int.bitWidth {
        if distance < Int.zero {
          return distance
        }
      } else {
        if absolute <= Self(truncatingIfNeeded: Int.min.magnitude) {
          return distance
        }
      }
    }
    _preconditionFailure("Distance is not representable in Int")
  }
}