[stdlib] More verbose debugDescription for NaNs

The format of debugDescription for NaN is:
[ '-' ] ( 'snan' | 'nan' ) [ '(0x' hexadecimal-digits ')' ]

Author: rintaro

stdlib/public/core/Runtime.swift.gyb

@@ -350,11 +350,26 @@ func _float${bits}ToStringImpl(
 
 func _float${bits}ToString(_ value: Float${bits}, debug: Bool) -> String {
 
-  if value.isInfinite {
-    return value.sign == .minus ? "-inf" : "inf"
-  }
-  if value.isNaN {
-    return "nan"
+  if !value.isFinite {
+    let significand = value.significandBitPattern
+    if significand == 0 {
+      // Infinity
+      return value.sign == .minus ? "-inf" : "inf"
+    }
+    else {
+      // NaN
+      if !debug {
+        return "nan"
+      }
+      let isSignaling = (significand & Float${bits}._quietNaNMask) == 0
+      let payload = significand & ((Float${bits}._quietNaNMask >> 1) - 1)
+      // FIXME(performance): Inefficient String manipulation. We could move
+      // this to C function.
+      return
+        (value.sign == .minus ? "-" : "")
+        + (isSignaling ? "snan" : "nan")
+        + (payload == 0 ? "" : ("(0x" + String(payload, radix: 16) + ")"))
+    }
   }
 
   _sanityCheck(sizeof(_Buffer32.self) == 32)

test/1_stdlib/PrintFloat.swift

@@ -56,6 +56,8 @@ PrintTests.test("Printable") {
   expectPrinted("-inf", -Float.infinity)
   expectPrinted("nan", Float.nan)
   expectPrinted("nan", -Float.nan)
+  expectPrinted("nan", Float.signalingNaN)
+  expectPrinted("nan", -Float.signalingNaN)
   expectPrinted("0.0", asFloat32(0.0))
   expectPrinted("1.0", asFloat32(1.0))
   expectPrinted("-1.0", asFloat32(-1.0))
@@ -66,12 +68,28 @@ PrintTests.test("Printable") {
   expectPrinted("-inf", -Double.infinity)
   expectPrinted("nan", Double.nan)
   expectPrinted("nan", -Double.nan)
+  expectPrinted("nan", Double.signalingNaN)
+  expectPrinted("nan", -Double.signalingNaN)
   expectPrinted("0.0", asFloat64(0.0))
   expectPrinted("1.0", asFloat64(1.0))
   expectPrinted("-1.0", asFloat64(-1.0))
   expectPrinted("100.125", asFloat64(100.125))
   expectPrinted("-100.125", asFloat64(-100.125))
 
+#if arch(i386) || arch(x86_64)
+  expectPrinted("inf", Float80.infinity)
+  expectPrinted("-inf", -Float80.infinity)
+  expectPrinted("nan", Float80.nan)
+  expectPrinted("nan", -Float80.nan)
+  expectPrinted("nan", Float80.signalingNaN)
+  expectPrinted("nan", -Float80.signalingNaN)
+  expectPrinted("0.0", asFloat80(0.0))
+  expectPrinted("1.0", asFloat80(1.0))
+  expectPrinted("-1.0", asFloat80(-1.0))
+  expectPrinted("100.125", asFloat80(100.125))
+  expectPrinted("-100.125", asFloat80(-100.125))
+#endif
+
   expectPrinted("1.00001", asFloat32(1.00001))
   expectPrinted("1.25e+17", asFloat32(125000000000000000.0))
   expectPrinted("1.25e+16", asFloat32(12500000000000000.0))
@@ -191,17 +209,48 @@ PrintTests.test("Printable") {
   expectDebugPrinted("1.24999998e+17", asFloat32(125000000000000000.0))
   expectDebugPrinted("1.25", asFloat32(1.25))
   expectDebugPrinted("1.24999997e-05", asFloat32(0.0000125))
+  expectDebugPrinted("inf", Float.infinity)
+  expectDebugPrinted("-inf", -Float.infinity)
+  expectDebugPrinted("nan", Float.nan)
+  expectDebugPrinted("-nan", -Float.nan)
+  expectDebugPrinted("nan(0xffff)", Float(nan: 65535, signaling: false))
+  expectDebugPrinted("-nan(0xffff)", -Float(nan: 65535, signaling: false))
+#if !arch(i386)
+  expectDebugPrinted("snan", Float.signalingNaN)
+  expectDebugPrinted("snan(0xffff)", Float(nan: 65535, signaling: true))
+  expectDebugPrinted("-snan(0xffff)", -Float(nan: 65535, signaling: true))
+#endif
 
   expectDebugPrinted("1.1000000000000001", asFloat64(1.1))
   expectDebugPrinted("1.25e+17", asFloat64(125000000000000000.0))
   expectDebugPrinted("1.25", asFloat64(1.25))
   expectDebugPrinted("1.2500000000000001e-05", asFloat64(0.0000125))
+  expectDebugPrinted("inf", Double.infinity)
+  expectDebugPrinted("-inf", -Double.infinity)
+  expectDebugPrinted("nan", Double.nan)
+  expectDebugPrinted("-nan", -Double.nan)
+  expectDebugPrinted("nan(0xffff)", Double(nan: 65535, signaling: false))
+  expectDebugPrinted("-nan(0xffff)", -Double(nan: 65535, signaling: false))
+#if !arch(i386)
+  expectDebugPrinted("snan", Double.signalingNaN)
+  expectDebugPrinted("snan(0xffff)", Double(nan: 65535, signaling: true))
+  expectDebugPrinted("-snan(0xffff)", -Double(nan: 65535, signaling: true))
+#endif
 
 #if arch(i386) || arch(x86_64)
   expectDebugPrinted("1.10000000000000000002", asFloat80(1.1))
   expectDebugPrinted("125000000000000000.0", asFloat80(125000000000000000.0))
   expectDebugPrinted("1.25", asFloat80(1.25))
   expectDebugPrinted("1.25000000000000000001e-05", asFloat80(0.0000125))
+  expectDebugPrinted("inf", Float80.infinity)
+  expectDebugPrinted("-inf", -Float80.infinity)
+  expectDebugPrinted("nan", Float80.nan)
+  expectDebugPrinted("-nan", -Float80.nan)
+  expectDebugPrinted("nan(0xffff)", Float80(nan: 65535, signaling: false))
+  expectDebugPrinted("-nan(0xffff)", -Float80(nan: 65535, signaling: false))
+  expectDebugPrinted("snan", Float80.signalingNaN)
+  expectDebugPrinted("snan(0xffff)", Float80(nan: 65535, signaling: true))
+  expectDebugPrinted("-snan(0xffff)", -Float80(nan: 65535, signaling: true))
 #endif
 }