Merge pull request swiftlang#30194 from xwu/floating-point-conversion-oops

Author: swift-ci

stdlib/public/core/FloatingPoint.swift

@@ -1858,23 +1858,24 @@ extension BinaryFloatingPoint {
     if source.significandWidth <= leadingBitIndex {
       return (value, true)
     }
-    // We promise to round to the closest representation, and if two
-    // representable values are equally close, the value with more trailing
-    // zeros in its significand bit pattern. Therefore, we must take a look at
-    // the bits that we've just truncated.
+    // We promise to round to the closest representation. Therefore, we must
+    // take a look at the bits that we've just truncated.
     let ulp = (1 as Source.RawSignificand) << -shift
     let truncatedBits = source.significandBitPattern & (ulp - 1)
     if truncatedBits < ulp / 2 {
       return (value, false)
     }
     let rounded = source.sign == .minus ? value.nextDown : value.nextUp
-    guard _fastPath(
-      truncatedBits != ulp / 2 ||
-        exponentBitPattern.trailingZeroBitCount <
-          rounded.exponentBitPattern.trailingZeroBitCount) else {
-      return (value, false)
+    if _fastPath(truncatedBits > ulp / 2) {
+      return (rounded, false)
     }
-    return (rounded, false)
+    // If two representable values are equally close, we return the value with
+    // more trailing zeros in its significand bit pattern.
+    return
+      significandBitPattern.trailingZeroBitCount >
+        rounded.significandBitPattern.trailingZeroBitCount
+      ? (value, false)
+      : (rounded, false)
   }
 
   /// Creates a new instance from the given value, rounded to the closest

test/stdlib/FloatingPoint.swift.gyb

@@ -206,6 +206,16 @@ FloatingPoint.test("BinaryFloatingPoint/genericFloatingPointConversion") {
     Float._convert(
       from: Double._convert(from: Float.leastNonzeroMagnitude).value).value,
     Float.leastNonzeroMagnitude)
+
+  // Let's make sure that the correct value is returned when two representable
+  // values are equally close to the original value.
+  let bitPattern: UInt64 = 0b01111111111_0000000000000000000000110000000000000000000000000000
+  var z = Double(bitPattern: bitPattern)
+  expectEqual(Float._convert(from: z).value, Float(z))
+
+  z = Double(Float.greatestFiniteMagnitude) +
+      Double(Float.greatestFiniteMagnitude.ulp / 2)
+  expectEqual(Float._convert(from: z).value, Float(z))
 }
 
 func positiveOne<T: ExpressibleByIntegerLiteral>() -> T {