Int->Int Failable Initializers

Author: Chris Williams

stdlib/public/core/FixedPoint.swift.gyb

@@ -256,9 +256,6 @@ public struct ${Self}
   }
 % end
 
-  /// Create an instance initialized to `value`.
-  @_transparent public
-  init(_ value: ${Self}) { self = value }
 
 %  if bits > 8:
   /// Creates an integer from its big-endian representation, changing the
@@ -429,44 +426,72 @@ extension ${Self} {
 extension ${Self} : SignedNumber {}
 % end
 
-// Construction from other integer types
-@_transparent
-extension ${Self} {
-% for src_ty in all_integer_types(word_bits):
-%    srcBits = src_ty.bits
-%    srcSigned = src_ty.is_signed
-%    Src = src_ty.stdlib_name
-%    (srcSign, srcExt) = ('s', 'sext') if srcSigned else ('u', 'zext')
-%    if Self != Src:
-  public init(_ v: ${Src}) {
+
+%{
+import gyb
+
+fixed_fixed_conversion_function = gyb.parse_template("fixed_fixed_conversion_function",
+"""
 %
-    let srcNotWord = v._value
+  let srcNotWord = value._value
+  let result: (value: Builtin.${BuiltinName}, error: Builtin.Int1)
 %
-%       if srcBits == bits and srcSign == sign:
-    let dstNotWord = srcNotWord
+%       if srcBits == bits and srcSign == sign: # Exact same size/signedness.
+  result = (srcNotWord, false._value)
 %
-%       elif srcBits == bits:
-    let tmp = Builtin.${srcSign}_to_${sign}_checked_conversion_Int${srcBits}(srcNotWord)
-    Builtin.condfail(tmp.1)
-    let dstNotWord = tmp.0
+%       elif srcBits == bits:  # Same size, switching signs.
+  result = Builtin.${srcSign}_to_${sign}_checked_conversion_Int${srcBits}(srcNotWord)
 %
-%       elif srcBits > bits:
-    let tmp = Builtin.${srcSign}_to_${sign}_checked_trunc_Int${srcBits}_Int${bits}(srcNotWord)
-    Builtin.condfail(tmp.1)
-    let dstNotWord = tmp.0
+%       elif srcBits > bits:  # Larger input, check for truncation.
+  result = Builtin.${srcSign}_to_${sign}_checked_trunc_Int${srcBits}_Int${bits}(srcNotWord)
 %
-%       elif srcSigned and not signed:
-    let tmp = Builtin.s_to_u_checked_conversion_Int${srcBits}(srcNotWord)
-    Builtin.condfail(tmp.1)
-    let dstNotWord = Builtin.${srcExt}_Int${srcBits}_Int${bits}(tmp.0)
+%       elif srcSigned and not signed: # Smaller size input, signed going to unsigned.
+  let (tmp, signError) = Builtin.s_to_u_checked_conversion_Int${srcBits}(srcNotWord)
+  result = (Builtin.${srcExt}_Int${srcBits}_Int${bits}(tmp), signError)
 %
-%       else:
-    let dstNotWord = Builtin.${srcExt}_Int${srcBits}_Int${bits}(srcNotWord)
+%       else: # Smaller size input, unsigned to signed or unsigned to unsigned.
+  result = (Builtin.${srcExt}_Int${srcBits}_Int${bits}(srcNotWord), false._value)
 %       end
-%
-    self._value = dstNotWord
+% 
+% if not safelyConvertable:
+  ${error_check}
+% end
+  self._value = result.value
+""")
+}%
+
+% for src_ty in all_integer_types(word_bits):
+%    srcBits = src_ty.bits
+%    srcSigned = src_ty.is_signed
+%    Src = src_ty.stdlib_name
+%    (srcSign, srcExt) = ('s', 'sext') if srcSigned else ('u', 'zext')
+%    safelyConvertable = (srcBits < bits and (srcSign == sign or signed)) or (srcBits == bits and srcSign == sign)
+
+@_transparent
+extension ${Self} {
+
+  @_transparent
+  public init(_ value: ${Src}) {
+    ${gyb.execute_template(
+        fixed_fixed_conversion_function,
+        error_check="Builtin.condfail(result.error)",
+        **locals()
+        )
+    }
+  }
+    
+% if safelyConvertable: 
+  @available(*, message: "Converting ${Src} to ${Self} will always succeed.")
+% end
+  @_transparent 
+  public init?(exactly value: ${Src}) {
+    ${gyb.execute_template(
+        fixed_fixed_conversion_function,
+        error_check="if Bool(result.error) == true { return nil }",
+        **locals()
+        )
+    }
   }
-%    end
 
 %    if should_define_truncating_bit_pattern_init(src_ty=src_ty, dst_ty=self_ty):
   /// Construct a `${Self}` having the same bitwise representation as
@@ -488,8 +513,10 @@ extension ${Self} {
   }
 
 %    end
+}
 % end
 
+extension ${Self} {
   /// Construct a `${Self}` having the same memory representation as
   /// the `${OtherSelf}` `bitPattern`.  No range or overflow checking
   /// occurs, and the resulting `${Self}` may not have the same numeric