[5.0][String] Add UTF-8 fast-paths for Foundation initializers (#22051)

* [String] Add UTF-8 fast-paths for Foundation initializers

Many Foundation initializers could benefit from faster string
construction and subsequent reads in Swift 5. Add UTF-8 fast paths for
when constructing a string from a valid UTF-8 code units.

* [String] Speed up ASCII checking.

Perform ASCII checking using pointer-width strides, making sure to
align properly.

Author: milseman

stdlib/public/SDK/Foundation/NSStringAPI.swift

@@ -178,6 +178,10 @@ extension String {
   /// Creates a string by copying the data from a given
   /// C array of UTF8-encoded bytes.
   public init?(utf8String bytes: UnsafePointer<CChar>) {
+    if let str = String(validatingUTF8: bytes) {
+      self = str
+      return
+    }
     if let ns = NSString(utf8String: bytes) {
       self = String._unconditionallyBridgeFromObjectiveC(ns)
     } else {
@@ -202,12 +206,18 @@ extension String {
   /// - Parameters:
   ///   - bytes: A sequence of bytes to interpret using `encoding`.
   ///   - encoding: The ecoding to use to interpret `bytes`.
-  public init? <S: Sequence>(bytes: __shared S, encoding: Encoding)
-    where S.Iterator.Element == UInt8 {
+  public init?<S: Sequence>(bytes: __shared S, encoding: Encoding)
+  where S.Iterator.Element == UInt8 {
     let byteArray = Array(bytes)
+    if encoding == .utf8,
+       let str = byteArray.withUnsafeBufferPointer({ String._tryFromUTF8($0) })
+    {
+      self = str
+      return
+    }
+
     if let ns = NSString(
       bytes: byteArray, length: byteArray.count, encoding: encoding.rawValue) {
-
       self = String._unconditionallyBridgeFromObjectiveC(ns)
     } else {
       return nil
@@ -365,6 +375,10 @@ extension String {
     cString: UnsafePointer<CChar>,
     encoding enc: Encoding
   ) {
+    if enc == .utf8, let str = String(validatingUTF8: cString) {
+      self = str
+      return
+    }
     if let ns = NSString(cString: cString, encoding: enc.rawValue) {
       self = String._unconditionallyBridgeFromObjectiveC(ns)
     } else {
@@ -381,6 +395,14 @@ extension String {
   /// Returns a `String` initialized by converting given `data` into
   /// Unicode characters using a given `encoding`.
   public init?(data: __shared Data, encoding: Encoding) {
+    if encoding == .utf8,
+       let str = data.withUnsafeBytes({
+         String._tryFromUTF8($0.bindMemory(to: UInt8.self))
+    }) {
+      self = str
+      return
+    }
+
     guard let s = NSString(data: data, encoding: encoding.rawValue) else { return nil }
     self = String._unconditionallyBridgeFromObjectiveC(s)
   }

stdlib/public/core/StringCreate.swift

@@ -15,13 +15,33 @@
 internal func _allASCII(_ input: UnsafeBufferPointer<UInt8>) -> Bool {
   // NOTE: Avoiding for-in syntax to avoid bounds checks
   //
-  // TODO(String performance): Vectorize and/or incorporate into validity
-  // checking, perhaps both.
+  // TODO(String performance): SIMD-ize
   //
   let ptr = input.baseAddress._unsafelyUnwrappedUnchecked
   var i = 0
-  while i < input.count {
-    guard ptr[i] <= 0x7F else { return false }
+
+  let count = input.count
+  let stride = MemoryLayout<UInt>.stride
+  let address = Int(bitPattern: ptr)
+
+  let wordASCIIMask = UInt(truncatingIfNeeded: 0x8080_8080_8080_8080 as UInt64)
+  let byteASCIIMask = UInt8(truncatingIfNeeded: wordASCIIMask)
+
+  while (address &+ i) % stride != 0 && i < count {
+    guard ptr[i] & byteASCIIMask == 0 else { return false }
+    i &+= 1
+  }
+
+  while (i &+ stride) <= count {
+    let word: UInt = UnsafePointer(
+      bitPattern: address &+ i
+    )._unsafelyUnwrappedUnchecked.pointee
+    guard word & wordASCIIMask == 0 else { return false }
+    i &+= stride
+  }
+
+  while i < count {
+    guard ptr[i] & byteASCIIMask == 0 else { return false }
     i &+= 1
   }
   return true
@@ -42,12 +62,10 @@ extension String {
     return storage.asString
   }
 
-  @usableFromInline
-  internal static func _tryFromUTF8(
-    _ input: UnsafeBufferPointer<UInt8>
-  ) -> String? {
+  public // SPI(Foundation)
+  static func _tryFromUTF8(_ input: UnsafeBufferPointer<UInt8>) -> String? {
     guard case .success(let extraInfo) = validateUTF8(input) else {
-        return nil
+      return nil
     }
 
     return String._uncheckedFromUTF8(input, isASCII: extraInfo.isASCII)

stdlib/public/core/StringUTF8Validation.swift

@@ -36,6 +36,10 @@ extension UTF8ValidationResult: Equatable {}
 private struct UTF8ValidationError: Error {}
 
 internal func validateUTF8(_ buf: UnsafeBufferPointer<UInt8>) -> UTF8ValidationResult {
+  if _allASCII(buf) {
+    return .success(UTF8ExtraInfo(isASCII: true))
+  }
+
   var iter = buf.makeIterator()
   var lastValidIndex = buf.startIndex