Merge pull request #42226 from glessard/rdar91343475

[stdlib] remove most uses of _asCChar and _asUInt8

Author: glessard

stdlib/public/core/CString.swift

@@ -45,15 +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 = String._fromUTF8Repairing(
-      UnsafeBufferPointer(start: nullTerminatedUTF8._asUInt8, 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:))
     }
   }
 
@@ -150,8 +152,9 @@ extension String {
   /// - Parameter cString: A pointer to a null-terminated UTF-8 code sequence.
   public init?(validatingUTF8 cString: UnsafePointer<CChar>) {
     let len = UTF8._nullCodeUnitOffset(in: cString)
-    guard let str = String._tryFromUTF8(
-      UnsafeBufferPointer(start: cString._asUInt8, count: len))
+    guard let str = cString.withMemoryRebound(to: UInt8.self, capacity: len, {
+      String._tryFromUTF8(UnsafeBufferPointer(start: $0, count: len))
+    })
     else { return nil }
 
     self = str
@@ -165,9 +168,10 @@ extension String {
         "input of String.init(validatingUTF8:) must be null-terminated"
       )
     }
-    guard let string = cString.prefix(length).withUnsafeBytes({
-      String._tryFromUTF8($0.assumingMemoryBound(to: UInt8.self))
-    }) else { return nil }
+    guard let string = cString.prefix(length).withUnsafeBufferPointer({
+      $0.withMemoryRebound(to: UInt8.self, String._tryFromUTF8(_:))
+    })
+    else { return nil }
 
     self = string
   }
@@ -244,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
       }
     }
 
@@ -279,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
       }
     }
 

stdlib/public/core/StringGuts.swift

@@ -167,8 +167,7 @@ extension _StringGuts {
     _ f: (UnsafeBufferPointer<CChar>) throws -> R
   ) rethrows -> R {
     return try self.withFastUTF8 { utf8 in
-      let ptr = utf8.baseAddress._unsafelyUnwrappedUnchecked._asCChar
-      return try f(UnsafeBufferPointer(start: ptr, count: utf8.count))
+      return try utf8.withMemoryRebound(to: CChar.self, f)
     }
   }
 }

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)