[stdlib] Re-add withContiguousStorageIfAvailable to SubString.UTF8View

This is a second pass at the original patch, which broke an OS test.

Due to an oversight it seems that we never added a
withContigousStorageIfAvailable implementation to SubString.UTF8View,
which meant that if you sliced a String you lost the ability to get fast
access to the backing storage. There's no good reason for this
functionality to be missing, so this patch adds it in by delegating to
the Slice implementation.

Resolves SR-11999.

Author: Lukasa

stdlib/public/core/Substring.swift

@@ -389,6 +389,13 @@ extension Substring.UTF8View: BidirectionalCollection {
     return _slice.distance(from: start, to: end)
   }
 
+  @_alwaysEmitIntoClient
+  public func withContiguousStorageIfAvailable<R>(
+    _ body: (UnsafeBufferPointer<Element>) throws -> R
+  ) rethrows -> R? {
+    return try _slice.withContiguousStorageIfAvailable(body)
+  }
+
   @inlinable
   public func _failEarlyRangeCheck(_ index: Index, bounds: Range<Index>) {
     _slice._failEarlyRangeCheck(index, bounds: bounds)

test/stdlib/subString.swift

@@ -12,6 +12,29 @@ func checkMatch<S: Collection, T: Collection>(_ x: S, _ y: T, _ i: S.Index)
   expectEqual(x[i], y[i])
 }
 
+func checkMatchContiguousStorage<S: Collection, T: Collection>(_ x: S, _ y: T, expected: Bool)
+  where S.Element == T.Element, S.Element: Equatable
+{
+  let xElement = x.withContiguousStorageIfAvailable { $0.first }
+  let yElement = y.withContiguousStorageIfAvailable { $0.first }
+
+  if expected {
+    expectEqual(xElement, yElement)
+  } else {
+    expectNotEqual(xElement, yElement)
+  }
+}
+
+func checkHasContiguousStorage<S: Collection>(_ x: S, expected: Bool) {
+  let hasStorage = x.withContiguousStorageIfAvailable { _ in true } ?? false
+  expectEqual(hasStorage, expected)
+}
+
+func checkHasContiguousStorageSubstring(_ x: Substring.UTF8View) {
+  let hasStorage = x.withContiguousStorageIfAvailable { _ in true } ?? false
+  expectTrue(hasStorage)
+}
+
 SubstringTests.test("Equality") {
   let s = "abcdefg"
   let s1 = s[s.index(s.startIndex, offsetBy: 2) ..<
@@ -228,6 +251,24 @@ SubstringTests.test("UTF8View") {
     expectEqual("", String(t.dropLast(100))!)
     expectEqual("", String(u.dropFirst(100))!)
     expectEqual("", String(u.dropLast(100))!)
+
+    let expectSubstringWCSIA: Bool
+    // This availability guard should refer to a concrete OS version in
+    // future.
+    if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *) {
+      expectSubstringWCSIA = true 
+    } else {
+      expectSubstringWCSIA = false
+    }
+
+    checkHasContiguousStorage(s.utf8, expected: true) // Strings always do
+    checkHasContiguousStorage(t, expected: expectSubstringWCSIA)
+    checkHasContiguousStorage(u, expected: expectSubstringWCSIA)
+    checkHasContiguousStorageSubstring(t)
+    checkHasContiguousStorageSubstring(u)
+    checkMatchContiguousStorage(Array(s.utf8), s.utf8, expected: true)
+    checkMatchContiguousStorage(Array(t), t, expected: expectSubstringWCSIA)
+    checkMatchContiguousStorage(Array(u), u, expected: expectSubstringWCSIA)
   }
 }