Implement SE-0065 "A New Model for Collections and Indices"

apinotes/CoreGraphics.apinotes

@@ -36,7 +36,7 @@ Functions:
 - Name: CGRectUnion
   SwiftName: "CGRect.union(self:_:)"
 - Name: CGRectIntersection
-  SwiftName: "CGRect.intersect(self:_:)"
+  SwiftName: "CGRect.intersection(self:_:)"
 - Name: CGRectContainsRect
   SwiftName: "CGRect.contains(self:_:)"
 - Name: CGRectContainsPoint

benchmark/single-source/Hash.swift

@@ -374,7 +374,10 @@ class SHA1 : Hash {
 
     // Init the rest of the "W" buffer.
     for t in 16..<80 {
-      w[t] = rol((w[t-3] ^ w[t-8] ^ w[t-14] ^ w[t-16]) ,1)
+      // splitting into 2 subexpressions to help typechecker
+      let lhs = w[t-3] ^ w[t-8]
+      let rhs = w[t-14] ^ w[t-16]
+      w[t] = rol(lhs ^ rhs, 1)
     }
 
     dataLength = 0

benchmark/single-source/PopFrontGeneric.swift

@@ -24,11 +24,11 @@ func _arrayReplace<B: _ArrayBufferProtocol, C: Collection
   _ target: inout B, _ subRange: Range<Int>, _ newValues: C
 ) {
   _precondition(
-    subRange.startIndex >= 0,
+    subRange.lowerBound >= 0,
     "Array replace: subRange start is negative")
 
   _precondition(
-    subRange.endIndex <= target.endIndex,
+    subRange.upperBound <= target.endIndex,
     "Array replace: subRange extends past the end")
 
   let oldCount = target.count

benchmark/single-source/RangeAssignment.swift

@@ -14,7 +14,7 @@ import TestsUtils
 
 @inline(never)
 public func run_RangeAssignment(_ scale: Int) {
-  let range = 100..<200
+  let range: Range = 100..<200
   var vector = [Double](repeating: 0.0 , count: 5000)
   let alfa = 1.0
   let N = 500*scale

benchmark/single-source/SetTests.swift

@@ -28,7 +28,7 @@ public func run_SetIsSubsetOf(_ N: Int) {
 
   var isSubset = false;
   for _ in 0 ..< N * 5000 {
-    isSubset = set.isSubsetOf(otherSet)
+    isSubset = set.isSubset(of: otherSet)
     if isSubset {
       break
     }
@@ -57,7 +57,7 @@ public func run_SetExclusiveOr(_ N: Int) {
 
   var xor = Set<Int>()
   for _ in 0 ..< N * 100 {
-    xor = set.exclusiveOr(otherSet)
+    xor = set.symmetricDifference(otherSet)
   }
   sink(&xor)
 }
@@ -99,7 +99,7 @@ public func run_SetIntersect(_ N: Int) {
 
   var and = Set<Int>()
   for _ in 0 ..< N * 100 {
-    and = set.intersect(otherSet)
+    and = set.intersection(otherSet)
   }
   sink(&and)
 }
@@ -139,7 +139,7 @@ public func run_SetIsSubsetOf_OfObjects(_ N: Int) {
 
   var isSubset = false;
   for _ in 0 ..< N * 5000 {
-    isSubset = set.isSubsetOf(otherSet)
+    isSubset = set.isSubset(of: otherSet)
     if isSubset {
       break
     }
@@ -168,7 +168,7 @@ public func run_SetExclusiveOr_OfObjects(_ N: Int) {
 
   var xor = Set<Box<Int>>()
   for _ in 0 ..< N * 100 {
-    xor = set.exclusiveOr(otherSet)
+    xor = set.symmetricDifference(otherSet)
   }
   sink(&xor)
 }
@@ -210,7 +210,7 @@ public func run_SetIntersect_OfObjects(_ N: Int) {
 
   var and = Set<Box<Int>>()
   for _ in 0 ..< N * 100 {
-    and = set.intersect(otherSet)
+    and = set.intersection(otherSet)
   }
   sink(&and)
 }

benchmark/single-source/StaticArray.swift

@@ -41,14 +41,17 @@ struct A2X<T : StaticArrayProtocol> : StaticArrayProtocol {
   func count() -> Int { return upper.count() + lower.count() }
 }
 
-struct StaticArray<T : StaticArrayProtocol> : StaticArrayProtocol, MutableCollection {
+struct StaticArray<
+  T : StaticArrayProtocol
+> : StaticArrayProtocol, RandomAccessCollection, MutableCollection {
   init(_ defaultValue : T.ElemTy) { values = T(defaultValue) }
   var values : T
   func get(_ idx: Int) -> T.ElemTy { return values.get(idx) }
   mutating func set(_ idx: Int,_ val : T.ElemTy) { return values.set(idx, val) }
   func count() -> Int { return values.count() }
 
   typealias Index = Int
+  typealias IndexDistance = Int
   let startIndex: Int = 0
   var endIndex: Int { return count()}
 
@@ -62,6 +65,11 @@ struct StaticArray<T : StaticArrayProtocol> : StaticArrayProtocol, MutableCollec
   }
 
   typealias Iterator = IndexingIterator<StaticArray>
+
+  subscript(bounds: Range<Index>) -> StaticArray<T> {
+    get { fatalError() }
+    set { fatalError() }
+  }
 }
 
 typealias SA2Int   = StaticArray<A0<Int>>

benchmark/single-source/StringInterpolation.swift

@@ -29,11 +29,12 @@ public func run_StringInterpolation(_ N: Int) {
     var result = 0
     for _ in 1...reps {
       let s = "\(anInt) abcdefdhijklmn \(aRefCountedObject) abcdefdhijklmn \u{01}"
+      let utf16 = s.utf16
 
       // FIXME: if String is not stored as UTF-16 on this platform, then the
       // following operation has a non-trivial cost and needs to be replaced
       // with an operation on the native storage type.
-      result = result &+ Int(s.utf16[s.utf16.endIndex.predecessor()])
+      result = result &+ Int(utf16[utf16.index(before: utf16.endIndex)])
     }
     CheckResults(result == refResult, "IncorrectResults in StringInterpolation: \(result) != \(refResult)")
   }

cmake/modules/SwiftHandleGybSources.cmake

@@ -106,7 +106,10 @@ function(handle_gyb_sources dependency_out_var_name sources_var_name arch)
       "${SWIFT_SOURCE_DIR}/utils/GYBUnicodeDataUtils.py"
       "${SWIFT_SOURCE_DIR}/utils/SwiftIntTypes.py"
       "${SWIFT_SOURCE_DIR}/utils/UnicodeData/GraphemeBreakProperty.txt"
-      "${SWIFT_SOURCE_DIR}/utils/UnicodeData/GraphemeBreakTest.txt")
+      "${SWIFT_SOURCE_DIR}/utils/UnicodeData/GraphemeBreakTest.txt"
+      "${SWIFT_SOURCE_DIR}/utils/gyb_stdlib_support.py"
+      "${SWIFT_SOURCE_DIR}/utils/gyb_stdlib_unittest_support.py"
+  )
   foreach (src ${${sources_var_name}})
     string(REGEX REPLACE "[.]gyb$" "" src_sans_gyb "${src}")
     if(src STREQUAL src_sans_gyb)

lib/SILOptimizer/Utils/Generics.cpp

@@ -606,6 +606,18 @@ bool swift::isWhitelistedSpecialization(StringRef SpecName) {
       "_ContiguousArrayBuffer",
       "Range",
       "RangeIterator",
+      "CountableRange",
+      "CountableRangeIterator",
+      "ClosedRange",
+      "ClosedRangeIterator",
+      "CountableClosedRange",
+      "CountableClosedRangeIterator",
+      "IndexingIterator",
+      "Collection",
+      "MutableCollection",
+      "BidirectionalCollection",
+      "RandomAccessCollection",
+      "RangeReplaceableCollection",
       "_allocateUninitializedArray",
       "UTF8",
       "UTF16",

stdlib/internal/SwiftExperimental/SwiftExperimental.swift

@@ -66,14 +66,14 @@ infix operator ⊉ { associativity left precedence 130 }
 public func ∖ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Set<T> {
-  return lhs.subtract(rhs)
+  return lhs.subtracting(rhs)
 }
 
 /// Assigns the relative complement between `lhs` and `rhs` to `lhs`.
 public func ∖= <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: inout Set<T>, rhs: S) {
-  lhs.subtractInPlace(rhs)
+  lhs.subtract(rhs)
 }
 
 /// - Returns: The union of `lhs` and `rhs`.
@@ -87,35 +87,35 @@ public func ∪ <
 public func ∪= <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: inout Set<T>, rhs: S) {
-  lhs.unionInPlace(rhs)
+  lhs.formUnion(rhs)
 }
 
 /// - Returns: The intersection of `lhs` and `rhs`.
 public func ∩ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Set<T> {
-  return lhs.intersect(rhs)
+  return lhs.intersection(rhs)
 }
 
 /// Assigns the intersection of `lhs` and `rhs` to `lhs`.
 public func ∩= <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: inout Set<T>, rhs: S) {
-  lhs.intersectInPlace(rhs)
+  lhs.formIntersection(rhs)
 }
 
 /// - Returns: A set with elements in `lhs` or `rhs` but not in both.
 public func ⨁ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Set<T> {
-  return lhs.exclusiveOr(rhs)
+  return lhs.symmetricDifference(rhs)
 }
 
 /// Assigns to `lhs` the set with elements in `lhs` or `rhs` but not in both.
 public func ⨁= <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: inout Set<T>, rhs: S) {
-  lhs.exclusiveOrInPlace(rhs)
+  lhs.formSymmetricDifference(rhs)
 }
 
 /// - Returns: True if `x` is in the set.
@@ -132,54 +132,54 @@ public func ∉ <T>(x: T, rhs: Set<T>) -> Bool {
 public func ⊂ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return lhs.isStrictSubsetOf(rhs)
+  return lhs.isStrictSubset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is not a strict subset of `rhs`.
 public func ⊄ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return !lhs.isStrictSubsetOf(rhs)
+  return !lhs.isStrictSubset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is a subset of `rhs`.
 public func ⊆ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return lhs.isSubsetOf(rhs)
+  return lhs.isSubset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is not a subset of `rhs`.
 public func ⊈ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return !lhs.isSubsetOf(rhs)
+  return !lhs.isSubset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is a strict superset of `rhs`.
 public func ⊃ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return lhs.isStrictSupersetOf(rhs)
+  return lhs.isStrictSuperset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is not a strict superset of `rhs`.
 public func ⊅ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return !lhs.isStrictSupersetOf(rhs)
+  return !lhs.isStrictSuperset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is a superset of `rhs`.
 public func ⊇ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return lhs.isSupersetOf(rhs)
+  return lhs.isSuperset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is not a superset of `rhs`.
 public func ⊉ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return !lhs.isSupersetOf(rhs)
+  return !lhs.isSuperset(of: rhs)
 }

stdlib/private/StdlibCollectionUnittest/CMakeLists.txt

@@ -14,13 +14,16 @@ add_swift_library(swiftStdlibCollectionUnittest SHARED IS_STDLIB
   # filename.
   StdlibCollectionUnittest.swift
 
-  CheckCollectionType.swift
+  CheckCollectionInstance.swift.gyb
+  CheckCollectionType.swift.gyb
   CheckMutableCollectionType.swift.gyb
   CheckRangeReplaceableCollectionType.swift
   CheckRangeReplaceableSliceType.swift
+  CheckSequenceInstance.swift.gyb
   CheckSequenceType.swift
   LoggingWrappers.swift.gyb
   MinimalCollections.swift.gyb
+  ../../public/core/WriteBackMutableSlice.swift
 
   PRIVATE_LINK_LIBRARIES ${swift_stdlib_unittest_private_link_libraries}
   SWIFT_MODULE_DEPENDS StdlibUnittest