stdlib: replace error-prone pairs of isASCII/startASCII calls with an API that returns Optional

Author: gribozavr

stdlib/public/core/OutputStream.swift

@@ -497,11 +497,13 @@ internal struct _Stdout : TextOutputStream {
   mutating func write(_ string: String) {
     if string.isEmpty { return }
 
-    if string._core.isASCII {
+    if let asciiBuffer = string._core.asciiBuffer {
       defer { _fixLifetime(string) }
 
-      _swift_stdlib_fwrite_stdout(UnsafePointer(string._core.startASCII),
-                                  string._core.count, 1)
+      _swift_stdlib_fwrite_stdout(
+        UnsafePointer(asciiBuffer.baseAddress!),
+        asciiBuffer.count,
+        1)
       return
     }
 

stdlib/public/core/String.swift

@@ -726,9 +726,9 @@ extension String {
   ///
   /// - Complexity: O(*n*)
   public func lowercased() -> String {
-    if self._core.isASCII {
-      let count = self._core.count
-      let source = self._core.startASCII
+    if let asciiBuffer = self._core.asciiBuffer {
+      let count = asciiBuffer.count
+      let source = asciiBuffer.baseAddress!
       let buffer = _StringBuffer(
         capacity: count, initialSize: count, elementWidth: 1)
       let dest = buffer.start
@@ -776,9 +776,9 @@ extension String {
   ///
   /// - Complexity: O(*n*)
   public func uppercased() -> String {
-    if self._core.isASCII {
-      let count = self._core.count
-      let source = self._core.startASCII
+    if let asciiBuffer = self._core.asciiBuffer {
+      let count = asciiBuffer.count
+      let source = asciiBuffer.baseAddress!
       let buffer = _StringBuffer(
         capacity: count, initialSize: count, elementWidth: 1)
       let dest = buffer.start

stdlib/public/core/StringCore.swift

@@ -240,6 +240,13 @@ public struct _StringCore {
     return _baseAddress!.assumingMemoryBound(to: UTF16.CodeUnit.self)
   }
 
+  public var asciiBuffer: UnsafeMutableBufferPointer<UTF8.CodeUnit>? {
+    if elementWidth != 1 {
+      return nil
+    }
+    return UnsafeMutableBufferPointer(start: startASCII, count: count)
+  }
+
   /// the native _StringBuffer, if any, or `nil`.
   public var nativeBuffer: _StringBuffer? {
     if !hasCocoaBuffer {

stdlib/public/core/StringLegacy.swift

@@ -147,15 +147,18 @@ extension String {
     if prefixCount == 0 {
       return true
     }
-    if selfCore.hasContiguousStorage && prefixCore.hasContiguousStorage {
-      if selfCore.isASCII && prefixCore.isASCII {
-        // Prefix longer than self.
-        if prefixCount > selfCore.count {
-          return false
-        }
-        return Int(_swift_stdlib_memcmp(
-          selfCore.startASCII, prefixCore.startASCII, prefixCount)) == 0
+    if let selfASCIIBuffer = selfCore.asciiBuffer,
+       let prefixASCIIBuffer = prefixCore.asciiBuffer {
+      if prefixASCIIBuffer.count > selfASCIIBuffer.count {
+        // Prefix is longer than self.
+        return false
       }
+      return Int(_swift_stdlib_memcmp(
+        selfASCIIBuffer.baseAddress!,
+        prefixASCIIBuffer.baseAddress!,
+        prefixASCIIBuffer.count)) == 0
+    }
+    if selfCore.hasContiguousStorage && prefixCore.hasContiguousStorage {
       let lhsStr = _NSContiguousString(selfCore)
       let rhsStr = _NSContiguousString(prefixCore)
       return lhsStr._unsafeWithNotEscapedSelfPointerPair(rhsStr) {
@@ -202,17 +205,19 @@ extension String {
     if suffixCount == 0 {
       return true
     }
-    if selfCore.hasContiguousStorage && suffixCore.hasContiguousStorage {
-      if selfCore.isASCII && suffixCore.isASCII {
-        // Suffix longer than self.
-        let selfCount = selfCore.count
-        if suffixCount > selfCount {
-          return false
-        }
-        return Int(_swift_stdlib_memcmp(
-                   selfCore.startASCII + (selfCount - suffixCount),
-                   suffixCore.startASCII, suffixCount)) == 0
+    if let selfASCIIBuffer = selfCore.asciiBuffer,
+       let suffixASCIIBuffer = suffixCore.asciiBuffer {
+      if suffixASCIIBuffer.count > selfASCIIBuffer.count {
+        // Suffix is longer than self.
+        return false
       }
+      return Int(_swift_stdlib_memcmp(
+        selfASCIIBuffer.baseAddress!
+          + (selfASCIIBuffer.count - suffixASCIIBuffer.count),
+        suffixASCIIBuffer.baseAddress!,
+        suffixASCIIBuffer.count)) == 0
+    }
+    if selfCore.hasContiguousStorage && suffixCore.hasContiguousStorage {
       let lhsStr = _NSContiguousString(selfCore)
       let rhsStr = _NSContiguousString(suffixCore)
       return lhsStr._unsafeWithNotEscapedSelfPointerPair(rhsStr) {

stdlib/public/core/StringUTF8.swift

@@ -35,16 +35,17 @@ extension _StringCore {
   func _encodeSomeUTF8(from i: Int) -> (Int, _UTF8Chunk) {
     _sanityCheck(i <= count)
 
-    if _fastPath(elementWidth == 1) {
+    if let asciiBuffer = self.asciiBuffer {
       // How many UTF-16 code units might we use before we've filled up
       // our _UTF8Chunk with UTF-8 code units?
-      let utf16Count = Swift.min(MemoryLayout<_UTF8Chunk>.size, count - i)
+      let utf16Count =
+        Swift.min(MemoryLayout<_UTF8Chunk>.size, asciiBuffer.count - i)
 
       var result: _UTF8Chunk = ~0 // Start with all bits set
 
       _memcpy(
         dest: UnsafeMutableRawPointer(Builtin.addressof(&result)),
-        src: startASCII + i,
+        src: asciiBuffer.baseAddress! + i,
         size: numericCast(utf16Count))
 
       // Convert the _UTF8Chunk into host endianness.
@@ -379,10 +380,6 @@ extension String {
     }
   }
 
-  public var _contiguousUTF8: UnsafeMutablePointer<UTF8.CodeUnit>? {
-    return _core.elementWidth == 1 ? _core.startASCII : nil
-  }
-
   /// A contiguously stored null-terminated UTF-8 representation of the string.
   ///
   /// To access the underlying memory, invoke `withUnsafeBufferPointer` on the
@@ -410,9 +407,10 @@ extension String {
   internal func _withUnsafeBufferPointerToUTF8<R>(
     _ body: (UnsafeBufferPointer<UTF8.CodeUnit>) throws -> R
   ) rethrows -> R {
-    let ptr = _contiguousUTF8
-    if ptr != nil {
-      return try body(UnsafeBufferPointer(start: ptr, count: _core.count))
+    if let asciiBuffer = self._core.asciiBuffer {
+      return try body(UnsafeBufferPointer(
+        start: asciiBuffer.baseAddress,
+        count: asciiBuffer.count))
     }
     var nullTerminatedUTF8 = ContiguousArray<UTF8.CodeUnit>()
     nullTerminatedUTF8.reserveCapacity(utf8.count + 1)