Optimize init?(_:, appending:) using direct bits manipulation

Author: valeriyvan

stdlib/public/core/SmallString.swift

@@ -323,21 +323,104 @@ extension _SmallString {
 
   @usableFromInline // @testable
   internal init?(_ base: _SmallString, appending other: _SmallString) {
-    let totalCount = base.count + other.count
+    let otherCount = other.count
+
+    if otherCount == 0 {
+      // Fast path: nothing to append
+      self = base
+      return
+    }
+
+    let baseCount = base.count
+    let totalCount = baseCount + otherCount
     guard totalCount <= _SmallString.capacity else { return nil }
 
-    // TODO(SIMD): The below can be replaced with just be a couple vector ops
+    let (resultLeading, resultTrailing) = base.zeroTerminatedRawCodeUnits
+    let (otherLeading, otherTrailing) = other.zeroTerminatedRawCodeUnits
+
+    // Use direct bit manipulation instead of byte-by-byte copying.
+    // This is more efficient than SIMD for such small data sizes (max 15 bytes).
+
+    if baseCount < 8 {
+      if baseCount + otherCount <= 8 {
+        // Everything fits in leading word
+        let shiftAmount = UInt64(baseCount) &* 8
+        let otherMask = (UInt64(1) &<< (UInt64(otherCount) &* 8)) &- 1
+        let otherBits = otherLeading & otherMask
+#if _endian(big)
+        let insertShift = UInt64(8 - baseCount - otherCount) &* 8
+        resultLeading |= otherBits &<< insertShift
+#else
+        resultLeading |= otherBits &<< shiftAmount
+#endif
+      } else {
+        // Spans both words
+        let leadingBytes = 8 - baseCount
+        let trailingBytes = otherCount - leadingBytes
+
+        // Copy leading portion
+        let shiftAmount = UInt64(baseCount) &* 8
+        let leadingMask = (UInt64(1) &<< (UInt64(leadingBytes) &* 8)) &- 1
+        let leadingBits = otherLeading & leadingMask
+#if _endian(big)
+        resultLeading |= leadingBits &<< (UInt64(8 - baseCount - leadingBytes) &* 8)
+#else
+        resultLeading |= leadingBits &<< shiftAmount
+#endif
 
-    var result = base
-    var writeIdx = base.count
-    for readIdx in 0..<other.count {
-      result[writeIdx] = other[readIdx]
-      writeIdx &+= 1
+        // Copy trailing portion
+        let trailingMask = (UInt64(1) &<< (UInt64(trailingBytes) &* 8)) &- 1
+#if _endian(big)
+        if leadingBytes < 8 {
+          let otherShift = UInt64(8 - leadingBytes) &* 8
+          let trailingBits = (otherLeading &>> otherShift) | (otherTrailing &<< (UInt64(leadingBytes) &* 8))
+          resultTrailing = trailingBits & trailingMask
+        } else {
+          resultTrailing = otherTrailing & trailingMask
+        }
+#else
+        if leadingBytes < 8 {
+          let otherShift = UInt64(leadingBytes) &* 8
+          let trailingBits = (otherLeading &>> otherShift) | (otherTrailing &<< (UInt64(8 - leadingBytes) &* 8))
+          resultTrailing = trailingBits & trailingMask
+        } else {
+          resultTrailing = otherTrailing & trailingMask
+        }
+#endif
+      }
+    } else {
+      // Base uses trailing word, append to trailing
+      let trailingIndex = baseCount - 8
+      let shiftAmount = UInt64(trailingIndex) &* 8
+      let availableBytes = 8 - trailingIndex
+
+      if otherCount <= availableBytes {
+        // Fits in trailing word
+        let otherMask = (UInt64(1) &<< (UInt64(otherCount) &* 8)) &- 1
+        let otherBits = otherLeading & otherMask
+#if _endian(big)
+        let insertShift = UInt64(availableBytes - otherCount) &* 8
+        resultTrailing |= otherBits &<< insertShift
+#else
+        resultTrailing |= otherBits &<< shiftAmount
+#endif
+      } else {
+        // This case shouldn't happen as totalCount > capacity would be caught above
+        // But for safety, fall back to original implementation
+        var result = base
+        var writeIdx = base.count
+        for readIdx in 0..<other.count {
+          result[writeIdx] = other[readIdx]
+          writeIdx &+= 1
+        }
+        let (leading, trailing) = result.zeroTerminatedRawCodeUnits
+        self.init(leading: leading, trailing: trailing, count: totalCount)
+        return
+      }
     }
-    _internalInvariant(writeIdx == totalCount)
 
-    let (leading, trailing) = result.zeroTerminatedRawCodeUnits
-    self.init(leading: leading, trailing: trailing, count: totalCount)
+    // Data is already clean from zeroTerminatedRawCodeUnits, no additional masking needed
+    self.init(leading: resultLeading, trailing: resultTrailing, count: totalCount)
   }
 }