Merge pull request #9722 from apple/stringprotocol-interchange

Author: swift-ci

stdlib/public/core/String.swift

@@ -110,6 +110,42 @@ public protocol StringProtocol
   ) rethrows -> Result
 }
 
+/// A protocol that provides fast access to a known representation of String.
+///
+/// Can be used to specialize generic functions that would otherwise end up
+/// doing grapheme breaking to vend individual characters.
+internal protocol _SwiftStringView {
+  /// A `String`, having the same contents as `self`, that may be unsuitable for
+  /// long-term storage.
+  var _ephemeralContent : String { get }
+  
+  /// A `String`, having the same contents as `self`, that is suitable for
+  /// long-term storage.
+  var _persistentContent : String { get }
+}
+
+extension _SwiftStringView {
+  var _ephemeralContent : String { return _persistentContent }
+}
+
+extension StringProtocol {
+  internal var _ephemeralString : String {
+    let s0 = self as? _SwiftStringView
+    if _fastPath(s0 != nil), let s1 = s0 { return s1._ephemeralContent }
+    return String(String.CharacterView(self))
+  }
+
+  internal var _persistentString : String {
+    let s0 = self as? _SwiftStringView
+    if _fastPath(s0 != nil), let s1 = s0 { return s1._persistentContent }
+    return String(String.CharacterView(self))
+  }
+}
+
+extension String : _SwiftStringView {
+  var _persistentContent : String { return characters._persistentContent }
+}
+
 /// Call body with a pointer to zero-terminated sequence of
 /// `TargetEncoding.CodeUnit` representing the same string as `source`, when
 /// `source` is interpreted as being encoded with `SourceEncoding`.

stdlib/public/core/StringCharacterView.swift

@@ -153,6 +153,20 @@ extension String {
   }
 }
 
+extension String.CharacterView : _SwiftStringView {
+  var _persistentContent : String {
+    // FIXME: we might want to make sure our _StringCore isn't somehow a slice
+    // of some larger storage before blindly wrapping/returning it as
+    // persistent.  That said, if current benchmarks are measuring these cases,
+    // we might end up regressing something by copying the storage.  For now,
+    // assume we are not a slice; we can come back and measure the effects of
+    // this fix later.  If we make the fix we should use the line below as an
+    // implementation of _ephemeralContent
+    return String(self._core)
+  }
+}
+
+
 /// `String.CharacterView` is a collection of `Character`.
 extension String.CharacterView : BidirectionalCollection {
   internal typealias UnicodeScalarView = String.UnicodeScalarView
@@ -658,9 +672,15 @@ extension String.CharacterView : RangeReplaceableCollection {
   ///
   /// - Parameter characters: A sequence of characters.
   public init<S : Sequence>(_ characters: S)
-    where S.Element == Character {
-    self = String.CharacterView()
-    self.append(contentsOf: characters)
+  where S.Element == Character {
+    let v0 = characters as? _SwiftStringView
+    if _fastPath(v0 != nil), let v = v0 {
+      self = v._persistentContent.characters
+    }
+    else {
+      self = String.CharacterView()
+      self.append(contentsOf: characters)
+    }
   }
 }
 

stdlib/public/core/StringUTF16.swift

@@ -352,6 +352,11 @@ extension String {
   public typealias UTF16Index = UTF16View.Index
 }
 
+extension String.UTF16View : _SwiftStringView {
+  var _ephemeralContent : String { return _persistentContent }
+  var _persistentContent : String { return String(self._core) }
+}
+
 extension String.UTF16View.Index : Comparable {
   // FIXME: swift-3-indexing-model: add complete set of forwards for Comparable 
   //        assuming String.UTF8View.Index continues to exist

stdlib/public/core/StringUTF8.swift

@@ -454,6 +454,11 @@ extension String {
   public typealias UTF8Index = UTF8View.Index
 }
 
+extension String.UTF8View : _SwiftStringView {
+  var _persistentContent : String { return String(self._core) }
+}
+
+
 extension String.UTF8View.Index : Comparable {
   // FIXME: swift-3-indexing-model: add complete set of forwards for Comparable 
   //        assuming String.UTF8View.Index continues to exist

stdlib/public/core/StringUnicodeScalarView.swift

@@ -326,6 +326,10 @@ extension String {
   public typealias UnicodeScalarIndex = UnicodeScalarView.Index
 }
 
+extension String.UnicodeScalarView : _SwiftStringView {
+  var _persistentContent : String { return String(_core) }
+}
+
 extension String {
   /// The string's value represented as a collection of Unicode scalar values.
   public var unicodeScalars: UnicodeScalarView {

stdlib/public/core/Substring.swift.gyb

@@ -257,6 +257,31 @@ public struct Substring : StringProtocol {
   }
 }
 
+extension Substring : _SwiftStringView {
+  var _persistentContent : String {
+    let wholeCore = _slice._base._core
+    let native = wholeCore.nativeBuffer
+    if _fastPath(native != nil), let n = native {
+      if _fastPath(
+        n.start == wholeCore._baseAddress && n.usedCount == wholeCore.count) {
+        return String(wholeCore)
+      }
+    }
+    var r = String()
+    r._core.append(_ephemeralContent._core)
+    _sanityCheck(r._core._owner !== _ephemeralContent._core._owner)
+    return r
+  }
+  
+  var _ephemeralContent : String {
+    let wholeCore = _slice._base._core
+    let subCore : _StringCore = wholeCore[
+      startIndex._base._position..<endIndex._base._position]
+    // check that we haven't allocated a new buffer for the result
+    _sanityCheck(subCore._owner === wholeCore._owner)
+    return String(subCore)
+  }
+}
 
 extension Substring : CustomReflectable {
   public var customMirror: Mirror {
@@ -361,6 +386,36 @@ extension Substring {
 
 #endif
 
+extension Substring : RangeReplaceableCollection {
+  public init<S : Sequence>(_ elements: S)
+  where S.Element == Character {
+    let e0 = elements as? _SwiftStringView
+    if _fastPath(e0 != nil), let e = e0 {
+      self = e._ephemeralContent[...]
+    }
+    else {
+      self = String(elements)[...]
+    }
+  }
+  
+  public mutating func append<S : Sequence>(contentsOf elements: S)
+  where S.Element == Character {
+    var c = self._ephemeralContent._core
+    self = Substring()
+    
+    let e0 = elements as? _SwiftStringView
+    if _fastPath(e0 != nil), let e1 = e0 {
+      c.append(contentsOf: e1._ephemeralContent.utf16)
+      self = String(c)[...]
+    }
+    else {
+      var s = String(c)
+      s.append(contentsOf: elements)
+      self = s[...]
+    }
+  }
+}
+
 extension Substring {
   public func lowercased() -> String {
     return String(self).lowercased()