Merge pull request #22450 from milseman/5_0_bug_zapper

[5.0][stdlib] Two String bug fixes

Author: airspeedswift

stdlib/public/core/ContiguouslyStored.swift

@@ -42,7 +42,7 @@ extension UnsafeBufferPointer: _HasContiguousBytes {
   func withUnsafeBytes<R>(
     _ body: (UnsafeRawBufferPointer) throws -> R
   ) rethrows -> R {
-    let ptr = UnsafeRawPointer(self.baseAddress._unsafelyUnwrappedUnchecked)
+    let ptr = UnsafeRawPointer(self.baseAddress)
     let len = self.count &* MemoryLayout<Element>.stride
     return try body(UnsafeRawBufferPointer(start: ptr, count: len))
   }
@@ -52,7 +52,7 @@ extension UnsafeMutableBufferPointer: _HasContiguousBytes {
   func withUnsafeBytes<R>(
     _ body: (UnsafeRawBufferPointer) throws -> R
   ) rethrows -> R {
-    let ptr = UnsafeRawPointer(self.baseAddress._unsafelyUnwrappedUnchecked)
+    let ptr = UnsafeRawPointer(self.baseAddress)
     let len = self.count &* MemoryLayout<Element>.stride
     return try body(UnsafeRawBufferPointer(start: ptr, count: len))
   }

stdlib/public/core/SmallString.swift

@@ -242,6 +242,11 @@ extension _SmallString {
   // Direct from UTF-8
   @inlinable @inline(__always)
   internal init?(_ input: UnsafeBufferPointer<UInt8>) {
+    if input.isEmpty {
+      self.init()
+      return
+    }
+
     let count = input.count
     guard count <= _SmallString.capacity else { return nil }
 

stdlib/public/core/String.swift

@@ -405,10 +405,9 @@ extension String {
        contigBytes._providesContiguousBytesNoCopy
     {
       self = contigBytes.withUnsafeBytes { rawBufPtr in
-        let ptr = rawBufPtr.baseAddress._unsafelyUnwrappedUnchecked
         return String._fromUTF8Repairing(
           UnsafeBufferPointer(
-            start: ptr.assumingMemoryBound(to: UInt8.self),
+            start: rawBufPtr.baseAddress?.assumingMemoryBound(to: UInt8.self),
             count: rawBufPtr.count)).0
       }
       return
@@ -836,7 +835,7 @@ extension String {
     }
     return codeUnits
   }
-  
+
   public // @testable
   func _withNFCCodeUnits(_ f: (UInt8) throws -> Void) rethrows {
     try _gutsSlice._withNFCCodeUnits(f)

stdlib/public/core/StringCreate.swift

@@ -13,6 +13,8 @@
 //===----------------------------------------------------------------------===//
 
 internal func _allASCII(_ input: UnsafeBufferPointer<UInt8>) -> Bool {
+  if input.isEmpty { return true }
+
   // NOTE: Avoiding for-in syntax to avoid bounds checks
   //
   // TODO(String performance): SIMD-ize
@@ -146,9 +148,8 @@ extension String {
     _ body: (UnsafeBufferPointer<UTF8.CodeUnit>) throws -> R
   ) rethrows -> R {
     return try self.withUnsafeBytes { rawBufPtr in
-      let rawPtr = rawBufPtr.baseAddress._unsafelyUnwrappedUnchecked
       return try body(UnsafeBufferPointer(
-        start: rawPtr.assumingMemoryBound(to: UInt8.self),
+        start: rawBufPtr.baseAddress?.assumingMemoryBound(to: UInt8.self),
         count: rawBufPtr.count))
     }
   }

stdlib/public/core/StringUTF8View.swift

@@ -241,11 +241,7 @@ extension String {
   @inlinable
   public var utf8: UTF8View {
     @inline(__always) get { return UTF8View(self._guts) }
-    set {
-      // TODO(String testing): test suite doesn't currenlty exercise this code at
-      // all, test it.
-      self = String(utf8._guts)
-    }
+    set { self = String(newValue._guts) }
   }
 
   /// A contiguously stored null-terminated UTF-8 representation of the string.

test/stdlib/StringCreate.swift

@@ -0,0 +1,56 @@
+// RUN: %target-run-simple-swift
+// REQUIRES: executable_test
+
+import StdlibUnittest
+defer { runAllTests() }
+
+var StringCreateTests = TestSuite("StringCreateTests")
+
+enum SimpleString: String {
+  case smallASCII = "abcdefg"
+  case smallUnicode = "abéÏ𓀀"
+  case largeASCII = "012345678901234567890"
+  case largeUnicode = "abéÏ012345678901234567890𓀀"
+  case emoji = "😀😃🤢🤮👩🏿‍🎤🧛🏻‍♂️🧛🏻‍♂️👩‍👩‍👦‍👦"
+}
+
+let simpleStrings: [String] = [
+    SimpleString.smallASCII.rawValue,
+    SimpleString.smallUnicode.rawValue,
+    SimpleString.largeASCII.rawValue,
+    SimpleString.largeUnicode.rawValue,
+    SimpleString.emoji.rawValue,
+    "",
+]
+
+extension String {
+  var utf32: [UInt32] { return unicodeScalars.map { $0.value } }
+}
+
+StringCreateTests.test("String(decoding:as)") {
+  func validateDecodingAs(_ str: String) {
+    // Non-contiguous (maybe) storage
+    expectEqual(str, String(decoding: str.utf8, as: UTF8.self))
+    expectEqual(str, String(decoding: str.utf16, as: UTF16.self))
+    expectEqual(str, String(decoding: str.utf32, as: UTF32.self))
+
+    // Contiguous storage
+    expectEqual(str, String(decoding: Array(str.utf8), as: UTF8.self))
+    expectEqual(str, String(decoding: Array(str.utf16), as: UTF16.self))
+    expectEqual(str, String(decoding: Array(str.utf32), as: UTF32.self))
+
+  }
+
+  for str in simpleStrings {
+    validateDecodingAs(str)
+  }
+
+  // Corner-case: UBP with null pointer (https://bugs.swift.org/browse/SR-9869)
+  expectEqual(
+    "", String(decoding: UnsafeBufferPointer(_empty: ()), as: UTF8.self))
+  expectEqual(
+    "", String(decoding: UnsafeBufferPointer(_empty: ()), as: UTF16.self))
+  expectEqual(
+    "", String(decoding: UnsafeBufferPointer(_empty: ()), as: UTF32.self))
+}
+

validation-test/stdlib/StringViews.swift

@@ -796,4 +796,28 @@ tests.test("String.UTF32View/BidirectionalCollection")
     test.unicodeScalars, test.string.unicodeScalars) { $0 == $1 }
 }
 
+tests.test("String View Setters") {
+  var string = "abcd🤠👨‍👨‍👦‍👦efg"
+
+  string.utf8 = winter.utf8
+  expectEqual(winter, string)
+  string.utf8 = summer.utf8
+  expectEqual(summer, string)
+
+  string.utf16 = winter.utf16
+  expectEqual(winter, string)
+  string.utf16 = summer.utf16
+  expectEqual(summer, string)
+
+  string.unicodeScalars = winter.unicodeScalars
+  expectEqual(winter, string)
+  string.unicodeScalars = summer.unicodeScalars
+  expectEqual(summer, string)
+
+  string = winter
+  expectEqual(winter, string)
+  string = summer
+  expectEqual(summer, string)
+}
+
 runAllTests()