[stdlib] Remove DoubleWidth<T> (#11141)

<rdar://problem/33493257>

Author: moiseev

stdlib/public/core/Integers.swift.gyb

@@ -2027,7 +2027,7 @@ ${overflowOperationComment(x.operator)}
   ///
   /// Use this method to calculate the full result of a product that would
   /// otherwise overflow. Unlike traditional truncating multiplication, the
-  /// `multipliedFullWidth(by:)` method returns an instance of DoubleWith<Self>,
+  /// `multipliedFullWidth(by:)` method returns a tuple,
   /// containing both the `high` and `low` parts of the product of `self` and
   /// `other`. The following example uses this method to multiply two `UInt8`
   /// values that normally overflow when multiplied:
@@ -2063,7 +2063,7 @@ ${overflowOperationComment(x.operator)}
   /// represent in the type, a runtime error may occur.
   ///
   /// - Parameters:
-  ///   - dividend: A DoubleWidth<Self> value containing the high and low parts
+  ///   - dividend: A tuple value containing the high and low parts
   ///     of a double-width integer. The `high` component of the value carries
   ///     the sign, if the type is signed.
   /// - Returns: A tuple containing the quotient and remainder of `dividend`
@@ -3168,290 +3168,6 @@ public func numericCast<T : BinaryInteger, U : BinaryInteger>(_ x: T) -> U {
 }
 
 
-//===----------------------------------------------------------------------===//
-//===--- DoubleWidth ------------------------------------------------------===//
-//===----------------------------------------------------------------------===//
-
-public struct DoubleWidth<T : FixedWidthInteger>
-  : FixedWidthInteger, _ExpressibleByBuiltinIntegerLiteral
-  where
-  T.Magnitude : FixedWidthInteger,
-  T.Magnitude.Magnitude == T.Magnitude {
-
-  public typealias High = T
-  public typealias Low = T.Magnitude
-
-  internal var _storage: (high: T, low: T.Magnitude)
-
-  internal init(_ _value: (High, Low)) {
-    self._storage = (high: _value.0, low: _value.1)
-  }
-
-  public var high: High {
-    return _storage.high
-  }
-
-  public var low: Low {
-    return _storage.low
-  }
-
-  // Numeric
-  //
-  public init() {
-    self.init((High(), Low()))
-  }
-
-  // integer
-  //
-  public var magnitude: DoubleWidth<Low> {
-    if T.isSigned && _storage.high < 0 {
-        return (DoubleWidth<T>() - self).magnitude
-    }
-    return DoubleWidth<Low>((
-      _storage.high.magnitude, _storage.low.magnitude))
-  }
-
-  public func isEqual(to rhs: DoubleWidth<T>) -> Bool {
-    return (_storage.high == rhs._storage.high) &&
-           (_storage.low == rhs._storage.low)
-  }
-
-  public func isLess(than rhs: DoubleWidth<T>) -> Bool {
-    if _storage.high < rhs._storage.high {
-      return true
-    }
-    if (_storage.high > rhs._storage.high) {
-      return false
-    }
-    return _storage.low < rhs._storage.low
-  }
-
-  public init<T : BinaryInteger>(_ source: T) {
-    fatalError()
-  }
-
-  public init?<T : BinaryInteger>(exactly source: T) {
-    fatalError()
-  }
-
-  public init<T : BinaryInteger>(extendingOrTruncating source: T) {
-    fatalError()
-  }
-
-  public init<T : FloatingPoint>(_ source: T) {
-    fatalError()
-  }
-
-  public init?<T : FloatingPoint>(exactly source: T) {
-    fatalError()
-  }
-
-  public func _word(at n: Int) -> UInt {
-    if T.bitWidth < ${word_bits} || T.bitWidth % ${word_bits} != 0 {
-      fatalError("_word(at:) is not supported on this type")
-    }
-    // TODO: move to Int128 just like init(_builtinIntegerLiteral:) ?
-    let wordsInT = T.bitWidth / ${word_bits}
-    return (n < wordsInT) ?
-      _storage.low._word(at: n) :
-      _storage.high._word(at: n - wordsInT)
-  }
-
-  public static var isSigned: Bool {
-    return T.isSigned
-  }
-
-  // fixed width
-  //
-  public static var max: DoubleWidth<T> {
-    return self.init((High.max, Low.max))
-  }
-
-  public static var min: DoubleWidth<T> {
-    return self.init((High.min, Low.min))
-  }
-
-  public static var bitWidth : Int { return 2 * T.bitWidth }
-
-% # This covers + and -
-% for x in binaryArithmetic['Numeric'][:2]:
-%   highAffectedByLowOverflow = 'T.max' if x.operator == '+' else 'T.min'
-  public func ${x.name}ReportingOverflow(_ rhs: DoubleWidth<T>)
-    -> (partialValue: DoubleWidth<T>, overflow: ArithmeticOverflow) {
-    let (low, lowOverflow) =
-      _storage.low.${x.name}ReportingOverflow(rhs._storage.low)
-    let (high, highOverflow) =
-      _storage.high.${x.name}ReportingOverflow(rhs._storage.high)
-    let isLowOverflow = lowOverflow == .overflow
-    let result = (high ${x.operator} (isLowOverflow ? 1 : 0), low)
-    let overflow = ArithmeticOverflow(
-      highOverflow == .overflow ||
-      high == ${highAffectedByLowOverflow} && isLowOverflow
-    )
-    return (partialValue: DoubleWidth<T>(result),
-      overflow: overflow)
-  }
-% end
-
-
-  public func multipliedReportingOverflow(
-    by rhs: DoubleWidth<T>
-  ) -> (partialValue: DoubleWidth<T>, overflow: ArithmeticOverflow) {
-    let isNegative = (self < DoubleWidth<T>()) != (rhs < DoubleWidth<T>())
-
-    func mul(_ x: Low, _ y: Low, _ carry: Low) -> (partial: Low, carry: Low) {
-      let pair = x.multipliedFullWidth(by: y)
-      let t = DoubleWidth<Low>(pair) + DoubleWidth<Low>((0, carry))
-      return (partial: t._storage.low, carry: t._storage.high)
-    }
-
-    var high: Low = 0
-    var low: Low = 0
-
-    func mkResult(_ isOverflow: Bool)
-      -> (partialValue: DoubleWidth<T>, overflow: ArithmeticOverflow) {
-
-      // TODO: High() cast fails
-      let result = DoubleWidth<T>((High(high), low))
-      if isNegative {
-        return DoubleWidth<T>().subtractingReportingOverflow(result)
-      }
-      return (partialValue: result, overflow: ArithmeticOverflow(isOverflow))
-    }
-
-    var carry: Low = 0
-
-    let lhs = self.magnitude
-    let rhs = rhs.magnitude
-
-    // TODO: gyb me!
-    let a = mul(rhs._storage.low, lhs._storage.low, carry)
-    low += a.partial
-    carry = a.carry
-    /*_log("(II) 1 (\(high), \(low)) carry: \(carry)")*/
-
-    let b = mul(rhs._storage.low, lhs._storage.high, carry)
-    high += b.partial
-    carry = b.carry
-    /*_log("(II) 2 (\(high), \(low)) carry: \(carry)")*/
-
-    if carry != 0 {
-      /*_log("(EE) overflow")*/
-      return mkResult(true)
-    }
-
-    let c = mul(rhs._storage.high, lhs._storage.low, carry)
-    low += c.partial
-    carry = c.carry
-    /*_log("(II) 3 (\(high), \(low)) carry: \(carry)")*/
-
-    let d = mul(rhs._storage.high, lhs._storage.high, carry)
-    high += d.partial
-    carry = d.carry
-    /*_log("(II) 4 (\(high), \(low)) carry: \(carry)")*/
-
-    /*if (carry > 0) { _log("(EE) overflow") }*/
-    return mkResult(carry > 0)
-  }
-
-  public func dividedReportingOverflow(by other: DoubleWidth<T>)
-    -> (partialValue: DoubleWidth<T>, overflow: ArithmeticOverflow) {
-    fatalError()
-  }
-
-  public func remainderReportingOverflow(dividingBy other: DoubleWidth<T>)
-    -> (partialValue: DoubleWidth<T>, overflow: ArithmeticOverflow) {
-    fatalError()
-  }
-
-  public func multipliedFullWidth(by other: DoubleWidth<T>)
-    -> (high: DoubleWidth<T>, low: DoubleWidth<T>.Magnitude) {
-    fatalError()
-  }
-
-  public func dividingFullWidth(
-    _ dividend: (high: DoubleWidth<T>, low: DoubleWidth<T>.Magnitude)
-  ) -> (quotient: DoubleWidth<T>, remainder: DoubleWidth<T>) {
-    fatalError()
-  }
-
-% for x in binaryBitwise + maskingShifts:
-  public static func ${x.operator}=(
-    lhs: inout DoubleWidth<T>, rhs: DoubleWidth<T>
-  ) {
-    fatalError()
-  }
-% end
-
-% for x in chain(*binaryArithmetic.values()):
-
-  // FIXME(integers): remove this once the operators are back to Numeric
-  public static func ${x.operator} (
-    lhs: DoubleWidth<T>, rhs: DoubleWidth<T>
-  ) -> DoubleWidth<T> {
-    var lhs = lhs
-    lhs ${x.operator}= rhs
-    return lhs
-  }
-
-  public static func ${x.operator}=(
-    lhs: inout DoubleWidth<T>, rhs: DoubleWidth<T>
-  ) {
-    fatalError()
-  }
-% end
-
-  public init(_truncatingBits bits: UInt) {
-    fatalError()
-  }
-
-  // other
-  //
-  public init(_builtinIntegerLiteral x: _MaxBuiltinIntegerType) {
-    fatalError("Method must be overridden")
-  }
-
-  public var description: String {
-    return "(\(_storage.high), \(_storage.low))"
-  }
-
-  public var leadingZeroBitCount: Int {
-    fatalError()
-  }
-
-  public var trailingZeroBitCount: Int {
-    fatalError()
-  }
-
-  public var nonzeroBitCount: Int {
-    fatalError()
-  }
-
-  public var hashValue: Int {
-    fatalError()
-  }
-
-  public init(littleEndian: DoubleWidth<T>) {
-    fatalError()
-  }
-
-  public init(bigEndian: DoubleWidth<T>) {
-    fatalError()
-  }
-
-  public var littleEndian: DoubleWidth<T> {
-    fatalError()
-  }
-
-  public var bigEndian: DoubleWidth<T> {
-    fatalError()
-  }
-
-  public var byteSwapped: DoubleWidth<T> {
-    fatalError()
-  }
-}
-
 // FIXME(integers): switch to using `FixedWidthInteger.unsafeAdding`
 internal func _unsafePlus(_ lhs: Int, _ rhs: Int) -> Int {
 #if INTERNAL_CHECKS_ENABLED