Merge pull request swiftlang#497 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

Sources/Foundation/JSONDecoder.swift

@@ -454,30 +454,30 @@ extension JSONDecoderImpl: Decoder {
                 return nsNumber.uint8Value as! T
             }
             if type == Int8.self, NSNumber(value: nsNumber.int8Value) == nsNumber {
-                return nsNumber.uint8Value as! T
+                return nsNumber.int8Value as! T
             }
             if type == UInt16.self, NSNumber(value: nsNumber.uint16Value) == nsNumber {
                 return nsNumber.uint16Value as! T
             }
             if type == Int16.self, NSNumber(value: nsNumber.int16Value) == nsNumber {
-                return nsNumber.uint16Value as! T
+                return nsNumber.int16Value as! T
             }
             if type == UInt32.self, NSNumber(value: nsNumber.uint32Value) == nsNumber {
                 return nsNumber.uint32Value as! T
             }
             if type == Int32.self, NSNumber(value: nsNumber.int32Value) == nsNumber {
-                return nsNumber.uint32Value as! T
+                return nsNumber.int32Value as! T
             }
             if type == UInt64.self, NSNumber(value: nsNumber.uint64Value) == nsNumber {
                 return nsNumber.uint64Value as! T
             }
             if type == Int64.self, NSNumber(value: nsNumber.int64Value) == nsNumber {
-                return nsNumber.uint64Value as! T
+                return nsNumber.int64Value as! T
             }
             if type == UInt.self, NSNumber(value: nsNumber.uintValue) == nsNumber {
                 return nsNumber.uintValue as! T
             }
-            if type == Int.self, NSNumber(value: nsNumber.uintValue) == nsNumber {
+            if type == Int.self, NSNumber(value: nsNumber.intValue) == nsNumber {
                 return nsNumber.intValue as! T
             }
         }

Sources/Foundation/NSStringAPI.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -20,7 +20,7 @@
 // This file is shared between two projects:
 //
 // 1. https://github.com/apple/swift/tree/master/stdlib/public/Darwin/Foundation
-// 2. https://github.com/apple/swift-corelibs-foundation/tree/master/Foundation
+// 2. https://github.com/apple/swift-corelibs-foundation/tree/main/Foundation
 //
 // If you change this file, you must update it in both places.
 
@@ -176,7 +176,7 @@ extension String {
     // + (instancetype)stringWithUTF8String:(const char *)bytes
 
     /// Creates a string by copying the data from a given
-    /// C array of UTF8-encoded bytes.
+    /// null-terminated C array of UTF8-encoded bytes.
     public init?(utf8String bytes: UnsafePointer<CChar>) {
         if let str = String(validatingUTF8: bytes) {
             self = str
@@ -188,6 +188,54 @@ extension String {
             return nil
         }
     }
+
+    /// Creates a string by copying the data from a given
+    /// null-terminated array of UTF8-encoded bytes.
+    @_alwaysEmitIntoClient
+    public init?(utf8String bytes: [CChar]) {
+        // the stdlib's validatingUTF8 [CChar] overload checks for null termination.
+        if let str = String(validatingUTF8: bytes) {
+            self = str
+            return
+        }
+        guard let nullPosition = bytes.firstIndex(of: 0) else {
+            fatalError(
+                "input of String.init(utf8String:) must be null-terminated"
+            )
+        }
+        let ns = bytes.withUnsafeBytes {
+            NSString(bytes: $0.baseAddress!,
+                     length: nullPosition,
+                     encoding: Encoding.utf8.rawValue)
+        }
+        guard let ns = ns else {
+            return nil
+        }
+        self = String._unconditionallyBridgeFromObjectiveC(ns)
+    }
+
+    @_alwaysEmitIntoClient
+    @available(*, deprecated, message: "Use a copy of the String argument")
+    public init?(utf8String bytes: String) {
+        var decoded = bytes
+        decoded.makeContiguousUTF8()
+        if let null = decoded.firstIndex(of: "\0") {
+            decoded = String(decoded[..<null])
+        }
+        self = decoded
+    }
+
+    @_alwaysEmitIntoClient
+    @available(*, deprecated, message: "Use String(_ scalar: Unicode.Scalar)")
+    public init?(utf8String bytes: inout CChar) {
+        // a byte interpreted as a buffer is valid only if the value is zero.
+        guard bytes == 0 else {
+            fatalError(
+                "input of String.init(utf8String:) must be null-terminated"
+            )
+        }
+        self = ""
+    }
 }
 
 extension String {
@@ -371,15 +419,16 @@ extension String {
     //     initWithCString:(const char *)nullTerminatedCString
     //     encoding:(NSStringEncoding)encoding
 
-    /// Produces a string containing the bytes in a given C array,
-    /// interpreted according to a given encoding.
-    public init?(
-        cString: UnsafePointer<CChar>,
-        encoding enc: Encoding
-        ) {
-        if enc == .utf8, let str = String(validatingUTF8: cString) {
-            self = str
-            return
+    /// Produces a string by copying the null-terminated bytes
+    /// in a given C array, interpreted according to a given encoding.
+    public init?(cString: UnsafePointer<CChar>, encoding enc: Encoding) {
+        if enc == .utf8 || enc == .ascii {
+            if let str = String(validatingUTF8: cString) {
+                if enc == .utf8 || str._guts._isContiguousASCII {
+                    self = str
+                    return
+                }
+            }
         }
         if let ns = NSString(cString: cString, encoding: enc.rawValue) {
             self = String._unconditionallyBridgeFromObjectiveC(ns)
@@ -388,6 +437,64 @@ extension String {
         }
     }
 
+    /// Produces a string by copying the null-terminated bytes
+    /// in a given array, interpreted according to a given encoding.
+    @_alwaysEmitIntoClient
+    public init?(cString: [CChar], encoding enc: Encoding) {
+        if enc == .utf8 || enc == .ascii {
+            // the stdlib's validatingUTF8 [CChar] overload checks for null termination.
+            if let str = String(validatingUTF8: cString) {
+                if enc == .utf8 || str._guts._isContiguousASCII {
+                    self = str
+                    return
+                }
+            }
+        }
+        guard let nullPosition = cString.firstIndex(of: 0) else {
+            fatalError(
+                "input of String.init(cString:encoding:) must be null-terminated"
+            )
+        }
+        let ns = cString.withUnsafeBytes {
+            NSString(bytes: $0.baseAddress!,
+                     length: nullPosition,
+                     encoding: enc.rawValue)
+        }
+        guard let ns = ns else {
+            return nil
+        }
+        self = String._unconditionallyBridgeFromObjectiveC(ns)
+    }
+
+    @_alwaysEmitIntoClient
+    @available(*, deprecated, message: "Use a copy of the String argument")
+    public init?(cString: String, encoding enc: Encoding) {
+        if enc == .utf8 || enc == .ascii {
+            var decoded = cString
+            decoded.makeContiguousUTF8()
+            if let null = decoded.firstIndex(of: "\0") {
+                decoded = String(decoded[..<null])
+            }
+            if enc == .utf8 || decoded.utf8.allSatisfy({ $0 < 128 }) {
+                self = decoded
+                return
+            }
+        }
+        return nil
+    }
+
+    @_alwaysEmitIntoClient
+    @available(*, deprecated, message: "Use String(_ scalar: Unicode.Scalar)")
+    public init?(cString: inout CChar, encoding enc: Encoding) {
+        // a byte interpreted as a buffer is valid only if the value is zero.
+        guard cString == 0 else {
+            fatalError(
+                "input of String.init(cString:encoding:) must be null-terminated"
+            )
+        }
+        self = ""
+    }
+
     // FIXME: handle optional locale with default arguments
 
     // - (instancetype)
@@ -465,7 +572,7 @@ extension String {
     }
 }
 
-extension StringProtocol where Index == String.Index {
+extension StringProtocol {
     //===--- Bridging Helpers -----------------------------------------------===//
     //===--------------------------------------------------------------------===//
 

Tests/Foundation/Tests/TestJSONEncoder.swift

@@ -656,6 +656,66 @@ class TestJSONEncoder : XCTestCase {
         }
     }
 
+    func test_encodeDecodeNumericTypesBaseline() throws {
+        struct NumericTypesStruct: Codable, Equatable {
+            let int8Value: Int8
+            let uint8Value: UInt8
+            let int16Value: Int16
+            let uint16Value: UInt16
+            let int32Value: Int32
+            let uint32Value: UInt32
+            let int64Value: Int64
+            let intValue: Int
+            let uintValue: UInt
+            let uint64Value: UInt64
+            let floatValue: Float
+            let doubleValue: Double
+            let decimalValue: Decimal
+        }
+
+        let source = NumericTypesStruct(
+            int8Value: -12,
+            uint8Value: 34,
+            int16Value: -5678, 
+            uint16Value: 9011,
+            int32Value: -12141516,
+            uint32Value: 17181920,
+            int64Value: -21222324252627,
+            intValue: -2829303132,
+            uintValue: 33343536,
+            uint64Value: 373839404142,
+            floatValue: 1.234,
+            doubleValue: 5.101520,
+            decimalValue: Decimal(10))
+
+        let data = try JSONEncoder().encode(source)
+        let destination = try JSONDecoder().decode(NumericTypesStruct.self, from: data)
+        XCTAssertEqual(source, destination)
+
+        // Ensure that if a value is expressed as a floating point number, it casts correctly into the underlying type.
+
+        let json = """
+        {
+            "int8Value": -12.0,
+            "uint8Value": 34.0,
+            "int16Value": -5678.0, 
+            "uint16Value": 9011.0,
+            "int32Value": -12141516.0,
+            "uint32Value": 17181920.0,
+            "int64Value": -21222324252627.0,
+            "intValue": -2829303132.0,
+            "uintValue": 33343536.0,
+            "uint64Value": 373839404142.0,
+            "floatValue": 1.234,
+            "doubleValue": 5.101520,
+            "decimalValue": 10.0
+        }
+        """
+
+        let destination2 = try JSONDecoder().decode(NumericTypesStruct.self, from: Data(json.utf8))
+        XCTAssertEqual(source, destination2)
+    }
+
     func test_numericLimits() {
         struct DataStruct: Codable {
             let int8Value: Int8?
@@ -1479,6 +1539,7 @@ extension TestJSONEncoder {
             ("test_encodingCustomDataEmpty", test_encodingCustomDataEmpty),
             ("test_encodingNonConformingFloats", test_encodingNonConformingFloats),
             ("test_encodingNonConformingFloatStrings", test_encodingNonConformingFloatStrings),
+            ("test_encodeDecodeNumericTypesBaseline", test_encodeDecodeNumericTypesBaseline),
             ("test_nestedContainerCodingPaths", test_nestedContainerCodingPaths),
             ("test_superEncoderCodingPaths", test_superEncoderCodingPaths),
             ("test_codingOfBool", test_codingOfBool),