Collection.length => .count

Author: gribozavr

docs/Generics.rst

@@ -261,9 +261,9 @@ requirements. Protocols can also contain operators, properties, and subscript
 operators::
   
   protocol RandomAccessContainer : Collection {
-    var length : Int
-    func ==(lhs : Self, rhs : Self)
-    subscript (i : Int) -> Element
+    var count: Int
+    func == (lhs: Self, rhs: Self)
+    subscript(i: Int) -> Element
   }
 
 Operator requirements can be satisfied by operator definitions, property

docs/HighLevelSILOptimizations.rst

@@ -195,7 +195,7 @@ array.check_subscript(index: Int)
   read. No state is written. Despite being read only, this operation is control
   dependent.
 
-array.get_length() -> Int
+array.get_count() -> Int
 
   Read the array count (``array.endIndex - array.startIndex``) from the storage
   descriptor. No elements are read. No state is written. This is neither guarded
@@ -204,7 +204,7 @@ array.get_length() -> Int
 array.get_capacity() -> Int
 
   Read the array capacity from the storage descriptor. The semantics
-  are identical to ``get_length`` except for the meaning of the return value.
+  are identical to ``get_count`` except for the meaning of the return value.
 
 array.make_mutable()
 
@@ -263,7 +263,7 @@ check_subscript  guards          get_element, get_element_address
 make_mutable     interferes-with props.isCocoa/needsElementTypeCheck
 get_elt_addr     interferes-with get_element, get_element_address,
                                  props.isCocoa/needsElementTypeCheck
-mutate_unknown   interferes-with get_element, check_subscript, get_length,
+mutate_unknown   interferes-with get_element, check_subscript, get_count,
                                  get_capacity, get_element_address,
                                  props.isCocoa/needsElementTypeCheck
 ================ =============== ==========================================

lib/SILOptimizer/Analysis/ArraySemantic.cpp

@@ -147,7 +147,7 @@ ArrayCallKind swift::ArraySemanticsCall::getKind() const {
             .Case("array.uninitialized", ArrayCallKind::kArrayUninitialized)
             .Case("array.check_subscript", ArrayCallKind::kCheckSubscript)
             .Case("array.check_index", ArrayCallKind::kCheckIndex)
-            .Case("array.get_length", ArrayCallKind::kGetCount)
+            .Case("array.get_count", ArrayCallKind::kGetCount)
             .Case("array.get_capacity", ArrayCallKind::kGetCapacity)
             .Case("array.get_element", ArrayCallKind::kGetElement)
             .Case("array.owner", ArrayCallKind::kGetArrayOwner)

stdlib/private/StdlibUnittest/CheckCollection.swift

@@ -14,10 +14,10 @@ public struct SubscriptRangeTest {
   public let expected: [OpaqueValue<Int>]
   public let collection: [OpaqueValue<Int>]
   public let bounds: Range<Int>
-  public let length: Int
+  public let count: Int
   public let loc: SourceLoc
 
-  public var isEmpty: Bool { return length == 0 }
+  public var isEmpty: Bool { return count == 0 }
 
   public func boundsIn<C : Collection>(c: C) -> Range<C.Index> {
     let i = c.startIndex
@@ -28,14 +28,13 @@ public struct SubscriptRangeTest {
 
   public init(
     expected: [Int], collection: [Int], bounds: Range<Int>,
-    length: Int,
+    count: Int,
     file: String = __FILE__, line: UInt = __LINE__
   ) {
-    require(length == collection.length)
     self.expected = expected.map(OpaqueValue.init)
     self.collection = collection.map(OpaqueValue.init)
     self.bounds = bounds
-    self.length = length
+    self.count = count
     self.loc = SourceLoc(file, line, comment: "test data")
   }
 }
@@ -114,66 +113,66 @@ public let subscriptRangeTests = [
     expected: [],
     collection: [],
     bounds: 0..<0,
-    length: 0),
+    count: 0),
 
   // Slice to the full extent.
   SubscriptRangeTest(
     expected: [ 1010 ],
     collection: [ 1010 ],
     bounds: 0..<1,
-    length: 1),
+    count: 1),
   SubscriptRangeTest(
     expected: [ 1010, 2020, 3030 ],
     collection: [ 1010, 2020, 3030 ],
     bounds: 0..<3,
-    length: 3),
+    count: 3),
 
   // Slice an empty prefix.
   SubscriptRangeTest(
     expected: [],
     collection: [ 1010, 2020, 3030 ],
     bounds: 0..<0,
-    length: 3),
+    count: 3),
 
   // Slice a prefix.
   SubscriptRangeTest(
     expected: [ 1010, 2020 ],
     collection: [ 1010, 2020, 3030 ],
     bounds: 0..<2,
-    length: 3),
+    count: 3),
 
   // Slice an empty suffix.
   SubscriptRangeTest(
     expected: [],
     collection: [ 1010, 2020, 3030 ],
     bounds: 3..<3,
-    length: 3),
+    count: 3),
 
   // Slice a suffix.
   SubscriptRangeTest(
     expected: [ 2020, 3030 ],
     collection: [ 1010, 2020, 3030 ],
     bounds: 1..<3,
-    length: 3),
+    count: 3),
 
   // Slice an empty range in the middle.
   SubscriptRangeTest(
     expected: [],
     collection: [ 1010, 2020, 3030 ],
     bounds: 2..<2,
-    length: 3),
+    count: 3),
 
   // Slice the middle part.
   SubscriptRangeTest(
     expected: [ 2020 ],
     collection: [ 1010, 2020, 3030 ],
     bounds: 1..<2,
-    length: 3),
+    count: 3),
   SubscriptRangeTest(
     expected: [ 2020, 3030, 4040 ],
     collection: [ 1010, 2020, 3030, 4040, 5050, 6060 ],
     bounds: 1..<4,
-    length: 6),
+    count: 6),
 ]
 
 public let prefixUpToTests = [
@@ -482,13 +481,13 @@ self.test("\(testNamePrefix).isEmpty/semantics") {
 }
 
 //===----------------------------------------------------------------------===//
-// length
+// count
 //===----------------------------------------------------------------------===//
 
-self.test("\(testNamePrefix).length/semantics") {
+self.test("\(testNamePrefix).count/semantics") {
   for test in subscriptRangeTests {
     let c = makeWrappedCollection(test.collection)
-    expectEqual(test.length, numericCast(c.length) as Int)
+    expectEqual(test.count, numericCast(c.count) as Int)
   }
 }
 
@@ -842,7 +841,7 @@ self.test("\(testNamePrefix).last") {
       expectEmpty(result)
     } else {
       expectOptionalEqual(
-        test.collection[test.length - 1],
+        test.collection[test.count - 1],
         result.map(extractValue)
       ) { $0.value == $1.value }
     }

stdlib/private/StdlibUnittest/CheckMutableCollection.swift.gyb

@@ -222,9 +222,9 @@ self.test("\(testNamePrefix)._withUnsafeMutableBufferPointerIfSupported()/semant
   for test in subscriptRangeTests {
     var c = makeWrappedCollection(test.collection)
     var result = c._withUnsafeMutableBufferPointerIfSupported {
-      (baseAddress, length) -> OpaqueValue<Array<OpaqueValue<Int>>> in
+      (baseAddress, count) -> OpaqueValue<Array<OpaqueValue<Int>>> in
       let bufferPointer =
-        UnsafeMutableBufferPointer(start: baseAddress, length: length)
+        UnsafeMutableBufferPointer(start: baseAddress, count: count)
       return OpaqueValue(Array(bufferPointer.map(extractValue)))
     }
     expectType(Optional<OpaqueValue<Array<OpaqueValue<Int>>>>.self, &result)
@@ -246,13 +246,13 @@ self.test("\(testNamePrefix).sorted/DispatchesThrough_withUnsafeMutableBufferPoi
   let sequence = [ 5, 4, 3, 2, 1 ]
 %   if predicate:
   let elements: [OpaqueValue<Int>] =
-    zip(sequence, 0..<sequence.length).map {
+    zip(sequence, 0..<sequence.count).map {
       OpaqueValue($0, identity: $1)
     }
   let c = makeWrappedCollection(elements)
 %   else:
   let elements: [MinimalComparableValue] =
-    zip(sequence, 0..<sequence.length).map {
+    zip(sequence, 0..<sequence.count).map {
       MinimalComparableValue($0, identity: $1)
     }
   let c = makeWrappedCollectionWithComparableElement(elements)
@@ -288,7 +288,7 @@ func checkSort_${'Predicate' if predicate else 'WhereElementIsComparable'}(
 %   if predicate:
   let extract = extractValue
   let elements: [OpaqueValue<Int>] =
-    zip(sequence, 0..<sequence.length).map {
+    zip(sequence, 0..<sequence.count).map {
       OpaqueValue($0, identity: $1)
     }
   let c = makeWrappedCollection(elements)
@@ -304,7 +304,7 @@ func checkSort_${'Predicate' if predicate else 'WhereElementIsComparable'}(
 
   let extract = extractValueFromComparable
   let elements: [MinimalComparableValue] =
-    zip(sequence, 0..<sequence.length).map {
+    zip(sequence, 0..<sequence.count).map {
       MinimalComparableValue($0, identity: $1)
     }
   let c = makeWrappedCollectionWithComparableElement(elements)
@@ -320,7 +320,7 @@ func checkSort_${'Predicate' if predicate else 'WhereElementIsComparable'}(
 
   // Check that we didn't lose any elements.
   expectEqualsUnordered(
-    0..<sequence.length,
+    0..<sequence.count,
     extractedResult.map { $0.identity })
 
   // Check that the elements are sorted.
@@ -589,7 +589,7 @@ func checkSortInPlace_${'Predicate' if predicate else 'WhereElementIsComparable'
 %   if predicate:
   let extract = extractValue
   let elements: [OpaqueValue<Int>] =
-    zip(sequence, 0..<sequence.length).map {
+    zip(sequence, 0..<sequence.count).map {
       OpaqueValue($0, identity: $1)
     }
 
@@ -606,7 +606,7 @@ func checkSortInPlace_${'Predicate' if predicate else 'WhereElementIsComparable'
 
   let extract = extractValueFromComparable
   let elements: [MinimalComparableValue] =
-    zip(sequence, 0..<sequence.length).map {
+    zip(sequence, 0..<sequence.count).map {
       MinimalComparableValue($0, identity: $1)
     }
 
@@ -618,7 +618,7 @@ func checkSortInPlace_${'Predicate' if predicate else 'WhereElementIsComparable'
 
   // Check that we didn't lose any elements.
   expectEqualsUnordered(
-    0..<sequence.length,
+    0..<sequence.count,
     extractedResult.map { $0.identity })
 
   // Check that the elements are sorted.
@@ -679,7 +679,7 @@ func checkPartition_${'Predicate' if predicate else 'WhereElementIsComparable'}(
 %   if predicate:
   let extract = extractValue
   let elements: [OpaqueValue<Int>] =
-    zip(sequence, 0..<sequence.length).map {
+    zip(sequence, 0..<sequence.count).map {
       OpaqueValue($0, identity: $1)
     }
 
@@ -690,7 +690,7 @@ func checkPartition_${'Predicate' if predicate else 'WhereElementIsComparable'}(
 
   let extract = extractValueFromComparable
   let elements: [MinimalComparableValue] =
-    zip(sequence, 0..<sequence.length).map {
+    zip(sequence, 0..<sequence.count).map {
       MinimalComparableValue($0, identity: $1)
     }
 
@@ -710,7 +710,7 @@ func checkPartition_${'Predicate' if predicate else 'WhereElementIsComparable'}(
 
   // Check that we didn't lose any elements.
   let identities = c.map { extract($0).identity }
-  expectEqualsUnordered(0..<sequence.length, identities)
+  expectEqualsUnordered(0..<sequence.count, identities)
 
   if verifyOrder {
     // All the elements in the first partition are less than the pivot
@@ -760,14 +760,14 @@ self.test("\(testNamePrefix).partition/DispatchesThrough_withUnsafeMutableBuffer
 %   if predicate:
   let extract = extractValue
   let elements: [OpaqueValue<Int>] =
-    zip(sequence, 0..<sequence.length).map {
+    zip(sequence, 0..<sequence.count).map {
       OpaqueValue($0, identity: $1)
     }
   let c = makeWrappedCollection(elements)
 %   else:
   let extract = extractValueFromComparable
   let elements: [MinimalComparableValue] =
-    zip(sequence, 0..<sequence.length).map {
+    zip(sequence, 0..<sequence.count).map {
       MinimalComparableValue($0, identity: $1)
     }
   let c = makeWrappedCollectionWithComparableElement(elements)

stdlib/private/StdlibUnittest/CheckRangeReplaceableCollection.swift

@@ -26,15 +26,15 @@ internal enum RangeSelection {
       case .LeftEdge: return collection.startIndex..<collection.startIndex
       case .RightEdge: return collection.endIndex..<collection.endIndex
       case .Middle:
-        let start = collection.startIndex.advancedBy(collection.length / 4)
-        let end = collection.startIndex.advancedBy(3 * collection.length / 4)
+        let start = collection.startIndex.advancedBy(collection.count / 4)
+        let end = collection.startIndex.advancedBy(3 * collection.count / 4)
         return start...end
       case .LeftHalf:
         let start = collection.startIndex
-        let end = start.advancedBy(collection.length / 2)
+        let end = start.advancedBy(collection.count / 2)
         return start..<end
       case .RightHalf:
-        let start = collection.startIndex.advancedBy(collection.length / 2)
+        let start = collection.startIndex.advancedBy(collection.count / 2)
         let end = collection.endIndex
         return start..<end
     }
@@ -50,9 +50,9 @@ internal enum IndexSelection {
   internal func indexIn<C : Collection>(collection: C) -> C.Index {
     switch self {
       case .Start: return collection.startIndex
-      case .Middle: return collection.startIndex.advancedBy(collection.length / 2)
+      case .Middle: return collection.startIndex.advancedBy(collection.count / 2)
       case .End: return collection.endIndex
-      case .Last: return collection.startIndex.advancedBy(collection.length - 1)
+      case .Last: return collection.startIndex.advancedBy(collection.count - 1)
     }
   }
 }
@@ -411,20 +411,21 @@ self.test("\(testNamePrefix).init(Sequence)/semantics") {
 }
 
 //===----------------------------------------------------------------------===//
-// init(repeating:length:)
+// init(repeating:count:)
 //===----------------------------------------------------------------------===//
 
-self.test("\(testNamePrefix).init(repeating:length:)/semantics") {
-  let c = C(repeating: wrapValue(OpaqueValue(42)), length: 3)
+self.test("\(testNamePrefix).init(repeating:count:)/semantics") {
+  let c = C(repeating: wrapValue(OpaqueValue(42)), count: 3)
   expectEqualSequence(
     [42, 42, 42],
     c.map { extractValue($0).value })
-  let empty = C(repeating: wrapValue(OpaqueValue(42)), length: 0)
+  let empty = C(repeating: wrapValue(OpaqueValue(42)), count: 0)
   expectEqualSequence(
     [],
     empty.map { extractValue($0).value })
+
   expectCrashLater()
-  C(repeating: wrapValue(OpaqueValue(42)), length: -1)
+  _ = C(repeating: wrapValue(OpaqueValue(42)), count: -1)
 }
 
 //===----------------------------------------------------------------------===//

stdlib/private/StdlibUnittest/CheckSequenceType.swift

@@ -1425,8 +1425,8 @@ public let zipTests = [
     leftovers: [], []),
 ]
 
-public func callGenericUnderestimatedLength<S : Sequence>(s: S) -> Int {
-  return s.underestimatedLength
+public func callGenericUnderestimatedCount<S : Sequence>(s: S) -> Int {
+  return s.underestimatedCount
 }
 
 extension TestSuite {