String Index Interchange, etc. (Changes for SE-0180 => swift-4.0-branch) (#10852)

* [stdlib] Index interchange, part I

* [stdlib] String index interchange, part II (UTF16)

* [stdlib] String index interchange, part III (UTF8)

* [stdlib] Bring back some SPI that Foundation-on-linux uses.

* [stdlib] Minimal docs for the new string index

* [stdlib] UTF8View Iterator and count specialization

* [stdlib] Foundation SPI fixup

* [stdlib] Fix a test: String.UTF8View has its own Iterator now

* [stdlib] Small correction to UTF8 Iterator

This works either way I suppose, but the code is clearer now.

* [stdlib] UTF8View: count by iterating

The fancy code didn't turn out to be any faster.

* [stdlib] Speed String.UTF8View.count even more

* [stdlib] Rebuild String.Index for UTF8View

* [stdlib] Drop a couple bogus duplicate tests

Only the last of each set of dups gets run anyway.  See
https://bugs.swift.org/browse/SR-5362

* [stdlib] Extend String index conversion tests for interchange

test the new APIs as well as the legacy failing conversions.

* [stdlib] Repair some doc comments

Drive-by fix while cherry-picking.

Author: Dave Abrahams

stdlib/public/SDK/Foundation/ExtraStringAPIs.swift

@@ -10,25 +10,24 @@
 //
 //===----------------------------------------------------------------------===//
 
-// Random access for String.UTF16View, only when Foundation is
-// imported.  Making this API dependent on Foundation decouples the
-// Swift core from a UTF16 representation.
-extension String.UTF16View.Index : Strideable {
+extension String.UTF16View.Index {
   /// Construct from an integer offset.
+  @available(swift, deprecated: 3.2)
+  @available(swift, obsoleted: 4.0)
   public init(_ offset: Int) {
     _precondition(offset >= 0, "Negative UTF16 index offset not allowed")
     self.init(_offset: offset)
   }
 
+  @available(swift, deprecated: 3.2)
+  @available(swift, obsoleted: 4.0)
   public func distance(to other: String.UTF16View.Index) -> Int {
     return _offset.distance(to: other._offset)
   }
 
+  @available(swift, deprecated: 3.2)
+  @available(swift, obsoleted: 4.0)
   public func advanced(by n: Int) -> String.UTF16View.Index {
     return String.UTF16View.Index(_offset.advanced(by: n))
   }
 }
-
-extension String.UTF16View : RandomAccessCollection {}
-extension String.UTF16View.Indices : RandomAccessCollection {}
-

stdlib/public/SDK/Foundation/NSStringAPI.swift

@@ -32,8 +32,8 @@ func _toNSArray<T, U : AnyObject>(_ a: [T], f: (T) -> U) -> NSArray {
 
 func _toNSRange(_ r: Range<String.Index>) -> NSRange {
   return NSRange(
-    location: r.lowerBound._utf16Index,
-    length: r.upperBound._utf16Index - r.lowerBound._utf16Index)
+    location: r.lowerBound.encodedOffset,
+    length: r.upperBound.encodedOffset - r.lowerBound.encodedOffset)
 }
 
 // We only need this for UnsafeMutablePointer, but there's not currently a way
@@ -72,10 +72,7 @@ extension String {
   /// Return an `Index` corresponding to the given offset in our UTF-16
   /// representation.
   func _index(_ utf16Index: Int) -> Index {
-    return Index(
-      _base: String.UnicodeScalarView.Index(_position: utf16Index),
-      in: characters
-    )
+    return Index(encodedOffset: utf16Index)
   }
 
   /// Return a `Range<Index>` corresponding to the given `NSRange` of
@@ -1260,7 +1257,7 @@ extension String {
   public
   func rangeOfComposedCharacterSequence(at anIndex: Index) -> Range<Index> {
     return _range(
-      _ns.rangeOfComposedCharacterSequence(at: anIndex._utf16Index))
+      _ns.rangeOfComposedCharacterSequence(at: anIndex.encodedOffset))
   }
 
   // - (NSRange)rangeOfComposedCharacterSequencesForRange:(NSRange)range
@@ -1610,15 +1607,15 @@ extension String {
   /// Returns a new string containing the characters of the
   /// `String` from the one at a given index to the end.
   public func substring(from index: Index) -> String {
-    return _ns.substring(from: index._utf16Index)
+    return _ns.substring(from: index.encodedOffset)
   }
 
   // - (NSString *)substringToIndex:(NSUInteger)anIndex
 
   /// Returns a new string containing the characters of the
   /// `String` up to, but not including, the one at a given index.
   public func substring(to index: Index) -> String {
-    return _ns.substring(to: index._utf16Index)
+    return _ns.substring(to: index.encodedOffset)
   }
 
   // - (NSString *)substringWithRange:(NSRange)aRange

stdlib/public/SDK/Foundation/URLComponents.swift

@@ -194,8 +194,8 @@ public struct URLComponents : ReferenceConvertible, Hashable, Equatable, _Mutabl
     private func _toStringRange(_ r : NSRange) -> Range<String.Index>? {
         guard r.location != NSNotFound else { return nil }
 
-        let utf16Start = String.UTF16View.Index(_offset: r.location)
-        let utf16End = String.UTF16View.Index(_offset: r.location + r.length)
+        let utf16Start = String.UTF16View.Index(encodedOffset: r.location)
+        let utf16End = String.UTF16View.Index(encodedOffset: r.location + r.length)
 
         guard let s = self.string else { return nil }
         guard let start = String.Index(utf16Start, within: s) else { return nil }

stdlib/public/core/CMakeLists.txt

@@ -124,6 +124,7 @@ set(SWIFTLIB_ESSENTIAL
   StringBuffer.swift
   StringComparable.swift
   StringCore.swift
+  StringIndex.swift
   StringInterpolation.swift
   StringLegacy.swift
   StringRangeReplaceableCollection.swift.gyb

stdlib/public/core/GroupInfo.json

@@ -17,6 +17,7 @@
     "StringComparable.swift",
     "StringCore.swift",
     "StringHashable.swift",
+    "StringIndex.swift",
     "StringIndexConversions.swift",
     "StringInterpolation.swift",
     "StringLegacy.swift",

stdlib/public/core/Sequence.swift

@@ -323,9 +323,11 @@ public protocol IteratorProtocol {
 /// traverse a sequence should be considered O(*n*) unless documented
 /// otherwise.
 public protocol Sequence {
+  /// A type representing the sequence's elements.
+  associatedtype Element
+
   /// A type that provides the sequence's iteration interface and
   /// encapsulates its iteration state.
-  associatedtype Element
   associatedtype Iterator : IteratorProtocol where Iterator.Element == Element
 
   /// A type that represents a subsequence of some of the sequence's elements.