[stdlib] less assumingMemoryBound, rebind instead

Author: glessard

stdlib/public/core/CString.swift

@@ -45,16 +45,17 @@ extension String {
   /// - Parameter nullTerminatedUTF8: A pointer to a null-terminated UTF-8 code sequence.
   public init(cString nullTerminatedUTF8: UnsafePointer<CChar>) {
     let len = UTF8._nullCodeUnitOffset(in: nullTerminatedUTF8)
-    self = nullTerminatedUTF8.withMemoryRebound(to: UInt8.self, capacity: len) {
-      String._fromUTF8Repairing(UnsafeBufferPointer(start: $0, count: len)).0
+    let buffer = UnsafeBufferPointer(start: nullTerminatedUTF8, count: len)
+    self = buffer.withMemoryRebound(to: UInt8.self) {
+      String._fromUTF8Repairing($0).0
     }
   }
 
   @inlinable
   @_alwaysEmitIntoClient
   public init(cString nullTerminatedUTF8: [CChar]) {
-    self = nullTerminatedUTF8.withUnsafeBytes {
-      String(_checkingCString: $0.assumingMemoryBound(to: UInt8.self))
+    self = nullTerminatedUTF8.withUnsafeBufferPointer {
+      $0.withMemoryRebound(to: UInt8.self, String.init(_checkingCString:))
     }
   }
 
@@ -247,14 +248,18 @@ extension String {
     guard let cPtr = cString else { return nil }
 
     if _fastPath(encoding == Unicode.UTF8.self) {
-      let ptr = UnsafeRawPointer(cPtr).assumingMemoryBound(to: UInt8.self)
-      let len = UTF8._nullCodeUnitOffset(in: ptr)
-      let codeUnits = UnsafeBufferPointer(start: ptr, count: len)
-      if isRepairing {
-        return String._fromUTF8Repairing(codeUnits)
-      } else {
-        guard let str = String._tryFromUTF8(codeUnits) else { return nil }
-        return (str, false)
+      let len = UTF8._nullCodeUnitOffset(
+        in: UnsafeRawPointer(cPtr).assumingMemoryBound(to: UInt8.self)
+      )
+      let bytes = UnsafeBufferPointer(start: cPtr, count: len)
+      return bytes.withMemoryRebound(to: UInt8.self) { codeUnits in
+        if isRepairing {
+          return String._fromUTF8Repairing(codeUnits)
+        }
+        else if let str = String._tryFromUTF8(codeUnits) {
+          return (str, false)
+        }
+        return nil
       }
     }
 
@@ -282,16 +287,17 @@ extension String {
     }
 
     if _fastPath(encoding == Unicode.UTF8.self) {
-      return cString.prefix(length).withUnsafeBytes {
-        buf -> (result: String, repairsMade: Bool)? in
-        let codeUnits = buf.assumingMemoryBound(to: UInt8.self)
-        if isRepairing {
-          return String._fromUTF8Repairing(codeUnits)
+      return cString.prefix(length).withUnsafeBufferPointer {
+        buffer -> (result: String, repairsMade: Bool)? in
+        return buffer.withMemoryRebound(to: UInt8.self) { codeUnits in
+          if isRepairing {
+            return String._fromUTF8Repairing(codeUnits)
+          }
+          else if let str = String._tryFromUTF8(codeUnits) {
+            return (str, false)
+          }
+          return nil
         }
-        else if let str = String._tryFromUTF8(codeUnits) {
-          return (str, false)
-        }
-        return nil
       }
     }
 

test/stdlib/StringAPICString.swift

@@ -254,9 +254,10 @@ CStringTests.test("String.cString.with.Array.CChar.input") {
   do {
     let (u8p, dealloc) = getASCIIUTF8()
     defer { dealloc() }
-    let cstr = UnsafeRawPointer(u8p).assumingMemoryBound(to: CChar.self)
-    let buffer = UnsafeBufferPointer(start: cstr, count: getUTF8Length(u8p)+1)
-    let str = String(cString: Array(buffer))
+    let buffer = UnsafeBufferPointer(start: u8p, count: getUTF8Length(u8p)+1)
+    let str = buffer.withMemoryRebound(to: CChar.self) {
+      String(cString: Array($0))
+    }
     str.withCString {
       $0.withMemoryRebound(to: UInt8.self, capacity: buffer.count) {
         expectEqualCString(u8p, $0)
@@ -324,9 +325,10 @@ CStringTests.test("String.validatingUTF8.with.Array.input") {
   do {
     let (u8p, dealloc) = getASCIIUTF8()
     defer { dealloc() }
-    let cstr = UnsafeRawPointer(u8p).assumingMemoryBound(to: CChar.self)
-    let buffer = UnsafeBufferPointer(start: cstr, count: getUTF8Length(u8p)+1)
-    let str = String(validatingUTF8: Array(buffer))
+    let buffer = UnsafeBufferPointer(start: u8p, count: getUTF8Length(u8p)+1)
+    let str = buffer.withMemoryRebound(to: CChar.self) {
+      String(validatingUTF8: Array($0))
+    }
     expectNotNil(str)
     str?.withCString {
       $0.withMemoryRebound(to: UInt8.self, capacity: buffer.count) {
@@ -382,9 +384,10 @@ CStringTests.test("String.decodeCString.with.Array.input") {
   do {
     let (u8p, dealloc) = getASCIIUTF8()
     defer { dealloc() }
-    let cstr = UnsafeRawPointer(u8p).assumingMemoryBound(to: Unicode.UTF8.CodeUnit.self)
-    let buffer = UnsafeBufferPointer(start: cstr, count: getUTF8Length(u8p)+1)
-    let result = String.decodeCString(Array(buffer), as: Unicode.UTF8.self)
+    let buffer = UnsafeBufferPointer(start: u8p, count: getUTF8Length(u8p)+1)
+    let result = buffer.withMemoryRebound(to: Unicode.UTF8.CodeUnit.self) {
+      String.decodeCString(Array($0), as: Unicode.UTF8.self)
+    }
     expectNotNil(result)
     expectEqual(result?.repairsMade, false)
     result?.result.withCString {
@@ -448,9 +451,10 @@ CStringTests.test("String.init.decodingCString.with.Array.input") {
   do {
     let (u8p, dealloc) = getASCIIUTF8()
     defer { dealloc() }
-    let cstr = UnsafeRawPointer(u8p).assumingMemoryBound(to: Unicode.UTF8.CodeUnit.self)
-    let buffer = UnsafeBufferPointer(start: cstr, count: getUTF8Length(u8p)+1)
-    let str = String(decodingCString: Array(buffer), as: Unicode.UTF8.self)
+    let buffer = UnsafeBufferPointer(start: u8p, count: getUTF8Length(u8p)+1)
+    let str = buffer.withMemoryRebound(to: Unicode.UTF8.CodeUnit.self) {
+      String(decodingCString: Array($0), as: Unicode.UTF8.self)
+    }
     str.withCString {
       $0.withMemoryRebound(to: UInt8.self, capacity: buffer.count) {
         expectEqualCString(u8p, $0)