[String] Define performance flags and plumb them throughout

Author: milseman

stdlib/public/core/SmallString.swift

@@ -112,7 +112,7 @@ extension _SmallString {
   internal func _invariantCheck() {
     // Avoid `asStringObject`, which triggers more invariant checks (runtime)
     var _object = _StringObject(zero:())
-    _object._otherBits = _storage.0
+    _object._countAndFlags = _StringObject.CountAndFlags(raw: _storage.0)
     _object._object = Builtin.reinterpretCast(_storage.1)
     _sanityCheck(_object.smallCount <= _SmallString.capacity)
     _sanityCheck(_object.smallIsASCII == computeIsASCII())

stdlib/public/core/String.swift

@@ -859,7 +859,7 @@ extension String: _ExpressibleByBuiltinStringLiteral {
       self = String(_StringGuts(smol))
       return
     }
-    self.init(_StringGuts(bufPtr, isKnownASCII: Bool(isASCII)))
+    self.init(_StringGuts(bufPtr, isASCII: Bool(isASCII)))
   }
 }
 

stdlib/public/core/StringBreadcrumbs.swift

@@ -55,6 +55,8 @@ internal final class _StringBreadcrumbs {
 
     self.utf16Length = i
     _sanityCheck(self.crumbs.count == 1 + (self.utf16Length / stride))
+
+    _invariantCheck()
   }
 }
 
@@ -92,6 +94,14 @@ extension _StringBreadcrumbs {
 
     return (crumb, lowerBound &* stride)
   }
+
+  #if !INTERNAL_CHECKS_ENABLED
+  @nonobjc @inline(__always) internal func _invariantCheck() {}
+  #else
+  @nonobjc @inline(never) @_effects(releasenone)
+  internal func _invariantCheck() {
+  }
+  #endif // INTERNAL_CHECKS_ENABLED
 }
 
 extension _StringGuts {

stdlib/public/core/StringBridge.swift

@@ -60,25 +60,6 @@ internal func _cocoaStringCopyCharacters(
     destination)
 }
 
-
-@_effects(releasenone)
-internal func _cocoaStringSlice(
-  _ target: _CocoaString, _ bounds: Range<Int>
-) -> _CocoaString {
-  let cfSelf: _swift_shims_CFStringRef = target
-
-  _sanityCheck(
-    _swift_stdlib_CFStringGetCharactersPtr(cfSelf) == nil,
-    "Known contiguously stored strings should already be converted to Swift")
-
-  let cfResult = _swift_stdlib_CFStringCreateWithSubstring(
-    nil, cfSelf, _swift_shims_CFRange(
-      location: bounds.lowerBound, length: bounds.count)) as AnyObject
-
-  return cfResult
-}
-
-
 @_effects(readonly)
 internal func _cocoaStringSubscript(
   _ target: _CocoaString, _ position: Int
@@ -91,10 +72,10 @@ internal func _cocoaStringSubscript(
 // Conversion from NSString to Swift's native representation
 //
 
-internal var kCFStringEncodingASCII : _swift_shims_CFStringEncoding {
+private var kCFStringEncodingASCII : _swift_shims_CFStringEncoding {
   @inline(__always) get { return 0x0600 }
 }
-internal var kCFStringEncodingUTF8 : _swift_shims_CFStringEncoding {
+private var kCFStringEncodingUTF8 : _swift_shims_CFStringEncoding {
   @inline(__always) get { return 0x8000100 }
 }
 
@@ -115,6 +96,7 @@ internal func _bridgeTagged(
   return length == numCharWritten ? count : nil
 }
 
+@_effects(releasenone) // @opaque
 internal func _cocoaUTF8Pointer(_ str: _CocoaString) -> UnsafePointer<UInt8>? {
   // TODO(UTF8): Is there a better interface here? This requires nul
   // termination and may assume ASCII.
@@ -125,23 +107,25 @@ internal func _cocoaUTF8Pointer(_ str: _CocoaString) -> UnsafePointer<UInt8>? {
   return ptr._asUInt8
 }
 
+private enum CocoaStringPointer {
+  case ascii(UnsafePointer<UInt8>)
+  case utf8(UnsafePointer<UInt8>)
+  case utf16(UnsafePointer<UInt16>)
+  case none
+}
+
 @_effects(readonly)
-internal func _getCocoaStringPointer(
+private func _getCocoaStringPointer(
   _ cfImmutableValue: _CocoaString
-) -> (UnsafeRawPointer?, isUTF16: Bool)  {
-  let nulTerminatedASCII = _cocoaUTF8Pointer(cfImmutableValue)
-
-  // start will hold the base pointer of contiguous storage, if it
-  // is found.
-  var start: UnsafeRawPointer?
-  let isUTF16 = (nulTerminatedASCII == nil)
-  if isUTF16 {
-    let utf16Buf = _swift_stdlib_CFStringGetCharactersPtr(cfImmutableValue)
-    start = UnsafeRawPointer(utf16Buf)
-  } else {
-    start = UnsafeRawPointer(nulTerminatedASCII)
+) -> CocoaStringPointer {
+  if let utf8Ptr = _cocoaUTF8Pointer(cfImmutableValue) {
+    // TODO(UTF8 perf): Remember Cocoa ASCII-ness
+    return .utf8(utf8Ptr)
+  }
+  if let utf16Ptr = _swift_stdlib_CFStringGetCharactersPtr(cfImmutableValue) {
+    return .utf16(utf16Ptr)
   }
-  return (start, isUTF16: isUTF16)
+  return .none
 }
 
 @usableFromInline
@@ -170,13 +154,19 @@ internal func _bridgeCocoaString(_ cocoaString: _CocoaString) -> _StringGuts {
     return _StringGuts(_SmallString(taggedCocoa: immutableCopy))
   }
 
-  let (start, isUTF16) = _getCocoaStringPointer(immutableCopy)
+  let (fastUTF8, isASCII): (Bool, Bool)
+  switch _getCocoaStringPointer(immutableCopy) {
+    case .ascii(_): (fastUTF8, isASCII) = (true, true)
+    case .utf8(_): (fastUTF8, isASCII) = (true, false)
+    default:  (fastUTF8, isASCII) = (false, false)
+  }
   let length = _stdlib_binary_CFStringGetLength(immutableCopy)
 
-  // Detect fast-UTF8 Cocoa
-  let fastUTF8 = !isUTF16 && start != nil
   return _StringGuts(
-    cocoa: immutableCopy, providesFastUTF8: fastUTF8, length: length)
+    cocoa: immutableCopy,
+    providesFastUTF8: fastUTF8,
+    isASCII: isASCII,
+    length: length)
 }
 
 extension String {
@@ -195,7 +185,7 @@ extension String {
     // other such visitors.
     if _guts._object.isSmall {
       return _guts._object.asSmallString.withUTF8 { bufPtr in
-        // TODO(UTF8 perf): worth isKnownASCII check for different encoding?
+        // TODO(UTF8 perf): worth isASCII check for different encoding?
         return _swift_stdlib_CFStringCreateWithBytes(
             nil, bufPtr.baseAddress._unsafelyUnwrappedUnchecked,
             bufPtr.count,
@@ -204,7 +194,9 @@ extension String {
       }
     }
     if _guts._object.isImmortal {
-      return _SharedStringStorage(immortal: _guts._object.fastUTF8)
+      return _SharedStringStorage(
+        immortal: _guts._object.fastUTF8.baseAddress!,
+        countAndFlags: _guts._object._countAndFlags)
     }
 
     _sanityCheck(_guts._object.hasObjCBridgeableObject,

stdlib/public/core/StringComparison.swift

@@ -88,7 +88,7 @@ internal func _compareStringsCanonical(
     return .equal
   }
 
-  if left.isKnownASCII && right.isKnownASCII {
+  if left.isASCII && right.isASCII {
     return left.withFastUTF8 { l in
       return right.withFastUTF8 { r in 
         return _StringComparison(signedNotation: l.compareASCII(to: r))

stdlib/public/core/StringCreate.swift

@@ -12,17 +12,33 @@
 // String Creation Helpers
 //===----------------------------------------------------------------------===//
 
+internal func _allASCII(_ input: UnsafeBufferPointer<UInt8>) -> Bool {
+  // NOTE: Avoiding for-in syntax to avoid bounds checks
+  //
+  // TODO(UTF8 perf): Vectorize and/or incorporate into validity checking,
+  // perhaps both.
+  //
+  let ptr = input.baseAddress._unsafelyUnwrappedUnchecked
+  var i = 0
+  while i < input.count {
+    guard ptr[i] <= 0x7F else { return false }
+    i &+= 1
+  }
+  return true
+}
+
 extension String {
   @usableFromInline
   internal static func _fromASCII(
     _ input: UnsafeBufferPointer<UInt8>
   ) -> String {
+    _sanityCheck(_allASCII(input), "not actually ASCII")
+
     if let smol = _SmallString(input) {
       return String(_StringGuts(smol))
     }
 
-    // TODO(UTF8): Do we want to do remember ASCII-ness?
-    let storage = _StringStorage.create(initializingFrom: input)
+    let storage = _StringStorage.create(initializingFrom: input, isASCII: true)
     return storage.asString
   }
 
@@ -73,8 +89,9 @@ extension String {
       return String(_StringGuts(smol))
     }
 
-    // TODO(UTF8): Do we want to do an ascii scan?
-    let storage = _StringStorage.create(initializingFrom: input)
+    let isASCII = false // TODO: _allASCII(input)
+    let storage = _StringStorage.create(
+      initializingFrom: input, isASCII: isASCII)
     return storage.asString
   }
 

stdlib/public/core/StringGuts.swift

@@ -59,14 +59,14 @@ extension _StringGuts {
   }
 
   @inlinable @inline(__always)
-  internal init(_ bufPtr: UnsafeBufferPointer<UInt8>, isKnownASCII: Bool) {
-    self.init(_StringObject(immortal: bufPtr, isASCII: isKnownASCII))
+  internal init(_ bufPtr: UnsafeBufferPointer<UInt8>, isASCII: Bool) {
+    self.init(_StringObject(immortal: bufPtr, isASCII: isASCII))
   }
 
   @inlinable @inline(__always)
   internal init(_ storage: _StringStorage) {
     // TODO(UTF8): We should probably store perf flags on the storage's capacity
-    self.init(_StringObject(storage, isASCII: false))
+    self.init(_StringObject(storage))
   }
 
   internal init(_ storage: _SharedStringStorage) {
@@ -83,9 +83,14 @@ extension _StringGuts {
     self.init(_StringObject(storage, isASCII: false))
   }
 
-  internal init(cocoa: AnyObject, providesFastUTF8: Bool, length: Int) {
+  internal init(
+    cocoa: AnyObject, providesFastUTF8: Bool, isASCII: Bool, length: Int
+  ) {
     self.init(_StringObject(
-      cocoa: cocoa, providesFastUTF8: providesFastUTF8, length: length))
+      cocoa: cocoa,
+      providesFastUTF8: providesFastUTF8,
+      isASCII: isASCII,
+      length: length))
   }
 }
 
@@ -99,7 +104,7 @@ extension _StringGuts {
   internal var isEmpty: Bool { @inline(__always) get { return count == 0 } }
 
   @inlinable
-  internal var isKnownASCII: Bool  {
+  internal var isASCII: Bool  {
     @inline(__always) get { return _object.isASCII }
   }
 

stdlib/public/core/StringGutsRangeReplaceable.swift

@@ -80,8 +80,10 @@ extension _StringGuts {
       self.uniqueNativeCapacity == nil || self.uniqueNativeCapacity! < n)
 
     if _fastPath(isFastUTF8) {
+      let isASCII = self.isASCII
       let storage = self.withFastUTF8 {
-        _StringStorage.create(initializingFrom: $0, capacity: n)
+        _StringStorage.create(
+          initializingFrom: $0, capacity: n, isASCII: isASCII)
       }
 
       // TODO(UTF8): Track known ascii
@@ -98,7 +100,7 @@ extension _StringGuts {
     let selfUTF8 = Array(String(self).utf8)
     selfUTF8.withUnsafeBufferPointer {
       self = _StringGuts(_StringStorage.create(
-        initializingFrom: $0, capacity: n))
+        initializingFrom: $0, capacity: n, isASCII: self.isASCII))
     }
   }
 
@@ -142,14 +144,17 @@ extension _StringGuts {
       "growth should produce uniqueness")
 
     if other.isFastUTF8 {
-      other.withFastUTF8 { self.appendInPlace($0) }
+      let otherIsASCII = other.isASCII
+      other.withFastUTF8 { self.appendInPlace($0, isASCII: otherIsASCII) }
       return
     }
     _foreignAppendInPlace(other)
   }
 
-  internal mutating func appendInPlace(_ other: UnsafeBufferPointer<UInt8>) {
-    self._object.nativeStorage.appendInPlace(other)
+  internal mutating func appendInPlace(
+    _ other: UnsafeBufferPointer<UInt8>, isASCII: Bool
+  ) {
+    self._object.nativeStorage.appendInPlace(other, isASCII: isASCII)
 
     // We re-initialize from the modified storage to pick up new count, flags,
     // etc.
@@ -162,7 +167,7 @@ extension _StringGuts {
     _sanityCheck(self.uniqueNativeUnusedCapacity != nil)
 
     var iter = String(other).utf8.makeIterator()
-    self._object.nativeStorage.appendInPlace(&iter)
+    self._object.nativeStorage.appendInPlace(&iter, isASCII: other.isASCII)
 
     // We re-initialize from the modified storage to pick up new count, flags,
     // etc.
@@ -207,7 +212,8 @@ extension _StringGuts {
     if isUniqueNative {
       if let replStr = newElements as? String, replStr._guts.isFastUTF8 {
         replStr._guts.withFastUTF8 {
-          uniqueNativeReplaceSubrange(bounds, with: $0)
+          uniqueNativeReplaceSubrange(
+            bounds, with: $0, isASCII: replStr._guts.isASCII)
         }
         return
       }
@@ -224,7 +230,8 @@ extension _StringGuts {
 
   internal mutating func uniqueNativeReplaceSubrange(
     _ bounds: Range<Index>,
-    with codeUnits: UnsafeBufferPointer<UInt8>
+    with codeUnits: UnsafeBufferPointer<UInt8>,
+    isASCII: Bool
   ) {
     let neededCapacity =
       bounds.lowerBound.encodedOffset