Merge pull request #19050 from apple/revert-19006-error-bridging-integer-type

Revert " [Foundation] Collapse (SignedInteger|UnsignedInteger) reqts into FixedWidthInteger"

Author: mikeash

stdlib/public/SDK/Foundation/NSError.swift

@@ -162,34 +162,17 @@ public extension CustomNSError {
   }
 }
 
-/// Convert an arbitrary binary integer to an Int, reinterpreting signed
-/// -> unsigned if needed but trapping if the result is otherwise not
-/// expressible.
-func unsafeBinaryIntegerToInt<T: BinaryInteger>(_ value: T) -> Int {
-    if T.isSigned {
-        return numericCast(value)
-    }
-
-    let uintValue: UInt = numericCast(value)
-    return Int(bitPattern: uintValue)
-}
-
-/// Convert from an Int to an arbitrary binary integer, reinterpreting signed ->
-/// unsigned if needed but trapping if the result is otherwise not expressible.
-func unsafeBinaryIntegerFromInt<T: BinaryInteger>(_ value: Int) -> T {
-  if T.isSigned {
-    return numericCast(value)
+extension CustomNSError where Self: RawRepresentable, Self.RawValue: SignedInteger {
+  // The error code of Error with integral raw values is the raw value.
+  public var errorCode: Int {
+    return numericCast(self.rawValue)
   }
-
-  let uintValue = UInt(bitPattern: value)
-  return numericCast(uintValue)
 }
 
-extension CustomNSError
-    where Self: RawRepresentable, Self.RawValue: FixedWidthInteger {
+extension CustomNSError where Self: RawRepresentable, Self.RawValue: UnsignedInteger {
   // The error code of Error with integral raw values is the raw value.
   public var errorCode: Int {
-    return unsafeBinaryIntegerToInt(self.rawValue)
+    return numericCast(self.rawValue)
   }
 }
 
@@ -202,7 +185,13 @@ public extension Error where Self : CustomNSError {
 }
 
 public extension Error where Self: CustomNSError, Self: RawRepresentable,
-    Self.RawValue: FixedWidthInteger {
+    Self.RawValue: SignedInteger {
+  /// Default implementation for customized NSErrors.
+  var _code: Int { return self.errorCode }  
+}
+
+public extension Error where Self: CustomNSError, Self: RawRepresentable,
+    Self.RawValue: UnsignedInteger {
   /// Default implementation for customized NSErrors.
   var _code: Int { return self.errorCode }  
 }
@@ -395,7 +384,7 @@ extension _BridgedNSError {
   public var _domain: String { return Self._nsErrorDomain }
 }
 
-extension _BridgedNSError where Self.RawValue: FixedWidthInteger {
+extension _BridgedNSError where Self.RawValue: SignedInteger {
   public var _code: Int { return Int(rawValue) }
 
   public init?(_bridgedNSError: NSError) {
@@ -409,6 +398,22 @@ extension _BridgedNSError where Self.RawValue: FixedWidthInteger {
   public var hashValue: Int { return _code }
 }
 
+extension _BridgedNSError where Self.RawValue: UnsignedInteger {
+  public var _code: Int {
+    return Int(bitPattern: UInt(rawValue))
+  }
+
+  public init?(_bridgedNSError: NSError) {
+    if _bridgedNSError.domain != Self._nsErrorDomain {
+      return nil
+    }
+
+    self.init(rawValue: RawValue(UInt(bitPattern: _bridgedNSError.code)))
+  }
+
+  public var hashValue: Int { return _code }
+}
+
 /// Describes a bridged error that stores the underlying NSError, so
 /// it can be queried.
 public protocol _BridgedStoredNSError :
@@ -441,14 +446,14 @@ internal func _stringDictToAnyHashableDict(_ input: [String : Any])
 /// Various helper implementations for _BridgedStoredNSError
 extension _BridgedStoredNSError {
   public var code: Code {
-    return Code(rawValue: unsafeBinaryIntegerFromInt(_nsError.code))!
+    return Code(rawValue: numericCast(_nsError.code))!
   }
 
   /// Initialize an error within this domain with the given ``code``
   /// and ``userInfo``.
   public init(_ code: Code, userInfo: [String : Any] = [:]) {
     self.init(_nsError: NSError(domain: Self.errorDomain,
-                                code: unsafeBinaryIntegerToInt(code.rawValue),
+                                code: numericCast(code.rawValue),
                                 userInfo: _stringDictToAnyHashableDict(userInfo)))
   }
 

stdlib/public/core/ErrorType.swift

@@ -211,14 +211,16 @@ extension Error {
   }
 }
 
-extension Error where Self: RawRepresentable, Self.RawValue: FixedWidthInteger {
+extension Error where Self: RawRepresentable, Self.RawValue: SignedInteger {
   // The error code of Error with integral raw values is the raw value.
   public var _code: Int {
-    if Self.RawValue.isSigned {
-      return numericCast(self.rawValue)
-    }
+    return numericCast(self.rawValue)
+  }
+}
 
-    let uintValue: UInt = numericCast(self.rawValue)
-    return Int(bitPattern: uintValue)
+extension Error where Self: RawRepresentable, Self.RawValue: UnsignedInteger {
+  // The error code of Error with integral raw values is the raw value.
+  public var _code: Int {
+    return numericCast(self.rawValue)
   }
 }

test/stdlib/Error.swift

@@ -1,6 +1,4 @@
-// RUN: %empty-directory(%t)
-// RUN: %target-build-swift -o %t/Error -DPTR_SIZE_%target-ptrsize -module-name main %s
-// RUN: %target-run %t/Error
+// RUN: %target-run-simple-swift
 // REQUIRES: executable_test
 
 import StdlibUnittest
@@ -145,20 +143,5 @@ ErrorTests.test("existential in lvalue") {
   expectEqual(0, LifetimeTracked.instances)
 }
 
-enum UnsignedError: UInt, Error {
-#if PTR_SIZE_64
-case negativeOne = 0xFFFFFFFFFFFFFFFF
-#elseif PTR_SIZE_32
-case negativeOne = 0xFFFFFFFF
-#else
-#error ("Unknown pointer size")
-#endif
-}
-
-ErrorTests.test("unsigned raw value") {
-  let negOne: Error = UnsignedError.negativeOne
-  expectEqual(-1, negOne._code)
-}
-
 runAllTests()
 

test/stdlib/ErrorBridged.swift

@@ -1,6 +1,4 @@
-// RUN: %empty-directory(%t)
-// RUN: %target-build-swift -o %t/ErrorBridged -DPTR_SIZE_%target-ptrsize -module-name main -swift-version 3 %s
-// RUN: %target-run %t/ErrorBridged
+// RUN: %target-run-simple-swift-swift3
 // REQUIRES: executable_test
 // REQUIRES: objc_interop
 
@@ -610,14 +608,6 @@ enum DefaultCustomizedError3 : UInt, CustomNSError {
   case bad = 9
   case worse = 115
 
-  #if PTR_SIZE_64
-  case dreadful = 0xFFFFFFFFFFFFFFFF
-#elseif PTR_SIZE_32
-  case dreadful = 0xFFFFFFFF
-#else
-#error ("Unknown pointer size")
-#endif
-  
   static var errorDomain: String {
     return "customized3"
   }
@@ -633,7 +623,6 @@ ErrorBridgingTests.test("Default-customized via CustomNSError") {
   expectEqual(1, (DefaultCustomizedError1.worse as NSError).code)
   expectEqual(13, (DefaultCustomizedError2.worse as NSError).code)
   expectEqual(115, (DefaultCustomizedError3.worse as NSError).code)
-  expectEqual(-1, (DefaultCustomizedError3.dreadful as NSError).code)
   expectEqual("main.DefaultCustomizedError1", (DefaultCustomizedError1.worse as NSError).domain)
   expectEqual("customized3", (DefaultCustomizedError3.worse as NSError).domain)
   expectEqual("main.DefaultCustomizedParent.ChildError", (DefaultCustomizedParent.ChildError.foo as NSError).domain)