SE-0080 (4/4) - Failable initializers for Float->Int

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -13,34 +13,18 @@
 import SwiftShims
 
 %{
+from SwiftIntTypes import all_integer_types
 from SwiftFloatingPointTypes import all_floating_point_types
 
 #
 # Utility code for later in this template
 #
 
-# Bit counts for all int types
-allIntBits = [8, 16, 32, 64, 'Int']
-
 # Number of bits in the Builtin.Word type
 word_bits = int(CMAKE_SIZEOF_VOID_P) * 8
 
 # Number of bits in integer literals.
 builtinIntLiteralBits = 2048
-
-def allInts():
-    for bits in allIntBits:
-        for signed in False, True:
-            yield bits, signed
-
-def baseIntName(name):
-    return 'Int' if name == 'Int' else 'Int' + str(name)
-
-def builtinIntName(name):
-    return 'Int' + str(word_bits) if name == 'Int' else 'Int' + str(name)
-
-def intName(name, signed):
-    return ('' if signed else 'U') + baseIntName(name)
 }%
 
 //  TODO: remove once integer proposal is available ----------------------------
@@ -832,15 +816,31 @@ public prefix func - (x: ${Self}) -> ${Self} {
 
 // Construction from integers.
 extension ${Self} {
-% for (srcBits, srcSigned) in allInts():
-%    That = intName(srcBits, srcSigned)
-%    ThatBuiltinName = builtinIntName(srcBits)
-%    sign = 's' if srcSigned else 'u'
+
+% for self_ty in all_integer_types(word_bits):
+%   That = self_ty.stdlib_name
+%   ThatBuiltinName = self_ty.builtin_name
+%   srcBits = self_ty.bits
+%   sign = 's' if self_ty.is_signed else 'u'
   @_transparent
   public init(_ v: ${That}) {
     _value = Builtin.${sign}itofp_${ThatBuiltinName}_FPIEEE${bits}(v._value)
   }
-% end
+
+%   if srcBits < SignificandBitCount:
+  @available(*, message: "Converting ${That} to ${Self} will always succeed.")
+%   end
+  @inline(__always)
+  public init?(exactly value: ${That}) {
+    _value = Builtin.${sign}itofp_${ThatBuiltinName}_FPIEEE${bits}(value._value)
+
+%   if srcBits < SignificandBitCount:
+    if ${That}(self) != value {
+      return nil
+    }
+%   end
+  }
+% end # all_integer_types
 }
 
 // Construction from other floating point numbers.

validation-test/stdlib/FloatingPointConversion.swift.gyb

@@ -11,9 +11,14 @@
 import StdlibUnittest
 
 %{
-from SwiftFloatingPointTypes import all_floating_point_types
+import gyb
+from SwiftFloatingPointTypes import all_floating_point_types, getFtoIBounds
+from SwiftIntTypes import all_integer_types
 }%
 
+var FixedPointConversionTruncations = TestSuite("FixedPointToFloatingPointConversionTruncations")
+var FixedPointConversionFailures = TestSuite("FixedPointToFloatingPointConversionFailures")
+
 var FloatingPointConversionTruncations = TestSuite("FloatingPointToFloatingPointConversionTruncations")
 var FloatingPointConversionFailures = TestSuite("FloatingPointToFloatingPointConversionFailures")
 
@@ -111,6 +116,75 @@ FloatingPointConversionFailures.test("${OtherFloat}To${Self}Conversion/AlwaysSuc
 
 %  end # for in all_floating_point_types (Other)
 
+%{
+
+float_to_int_conversion_template = gyb.parse_template("float_to_int_conversion",
+"""
+% for int_ty in all_integer_types(word_bits):
+%  OtherInt = int_ty.stdlib_name
+%  OtherMin = int_ty.min
+%  OtherMax = int_ty.max
+%  (FloatMin, FloatMax) = getFtoIBounds(self_type.bits, int_ty.bits, int_ty.is_signed)
+
+%  for testValue in [0, FloatMin, FloatMax, FloatMin - 1, FloatMax + 1, OtherMin, OtherMax]:
+
+%    if testValue < OtherMin or testValue > OtherMax: 
+%          # Can't construct `other` value, do nothing and continue.
+
+%    elif testValue >= FloatMin and testValue <= FloatMax:
+
+FixedPointConversionTruncations.test("${OtherInt}to${Self}Conversion/${testValue}") {
+  expectEqual(${Self}(${testValue} as ${OtherInt}), ${testValue})
+}
+
+FixedPointConversionFailures.test("${OtherInt}to${Self}FailableConversion/${testValue}") {
+  expectEqual(${Self}(exactly: ${testValue} as ${OtherInt}), ${testValue})
+}
+
+%    else:
+
+FixedPointConversionTruncations.test("${OtherInt}to${Self}Truncation/${testValue}") {
+  let value: ${OtherInt} = ${testValue}
+  let result = ${Self}(value)
+  expectNotEqual(${OtherInt}(result), value)
+}
+
+FixedPointConversionFailures.test("${OtherInt}to${Self}Failure/${testValue}") {
+  let value: ${OtherInt} = ${testValue}
+  let result = ${Self}(exactly: value)
+  expectEqual(result, ${OtherMin} as ${Self})
+  expectEqual(${OtherInt}(result!), value)
+}
+
+%    end
+
+%  end # testValue in testValues
+%  end # for in all_integer_types (Other)
+""")
+}%
+
+#if arch(i386) || arch(arm)
+
+  ${gyb.execute_template(
+      float_to_int_conversion_template,
+      word_bits=32,
+      **locals()
+      )}
+
+#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
+
+  ${gyb.execute_template(
+      float_to_int_conversion_template,
+      word_bits=64,
+      **locals()
+      )}
+
+#else
+
+_UnimplementedError()
+
+#endif
+
 %  if Self == 'Float80':
 #endif
 %  end