Switch range operators ".." and "...".

- 1..3 now means 1,2
- 1...3 now means 1,2,3

Implements <rdar://problem/16839891>

Swift SVN r18066

Author: tkremenek

stdlib/core/Algorithm.swift

@@ -145,8 +145,8 @@ func _quickSort<C: MutableCollection where C.IndexType: SignedInteger>(
 
    // Partition and sort.
   let part_idx : C.IndexType = partition(&elements, range, &less)
-  _quickSort(&elements, range.startIndex...part_idx, &less);
-  _quickSort(&elements, part_idx...range.endIndex, &less);
+  _quickSort(&elements, range.startIndex..part_idx, &less);
+  _quickSort(&elements, part_idx..range.endIndex, &less);
 }
 
 struct Less<T: Comparable> {
@@ -156,15 +156,15 @@ struct Less<T: Comparable> {
 }
 
 func sort<T>(var array: T[], pred: (T, T) -> Bool) -> T[] {
-  quickSort(&array, 0...array.count, pred)
+  quickSort(&array, 0..array.count, pred)
   return array
 }
 
 /// The functions below are a copy of the functions above except that
 /// they don't accept a predicate and they are hardcoded to use the less-than
 /// comparator.
 func sort<T : Comparable>(var array: T[]) -> T[] {
-  quickSort(&array, 0...array.count)
+  quickSort(&array, 0..array.count)
   return array
 }
 
@@ -254,8 +254,8 @@ func _quickSort<C: MutableCollection where C.GeneratorType.Element: Comparable,
   }
    // Partition and sort.
   let part_idx : C.IndexType = partition(&elements, range)
-  _quickSort(&elements, range.startIndex...part_idx);
-  _quickSort(&elements, part_idx...range.endIndex);
+  _quickSort(&elements, range.startIndex..part_idx);
+  _quickSort(&elements, part_idx..range.endIndex);
 }
 //// End of non-predicate sort functions.
 
@@ -320,7 +320,7 @@ func split<Seq: Sliceable, R:LogicValue>(
     if isSeparator(seq[j]) {
       if startIndex {
         var i = startIndex!
-        result.append(seq[i...j])
+        result.append(seq[i..j])
         startIndex = .Some(j.succ())
         if ++splits >= maxSplit {
           break
@@ -339,7 +339,7 @@ func split<Seq: Sliceable, R:LogicValue>(
 
   switch startIndex {
   case .Some(var i):
-    result.append(seq[i...seq.endIndex])
+    result.append(seq[i..seq.endIndex])
   default:
     ()
   }

stdlib/core/Arrays.swift.gyb

@@ -100,7 +100,7 @@ extension ${Self} : ArrayType {
     buffer = Buffer()
     reserve(count)
     var p = buffer.elementStorage
-    for _ in 0...count {
+    for _ in 0..count {
       p++.initialize(value)
     }
     buffer.count = count
@@ -156,7 +156,7 @@ extension ${Self} : ArrayType {
   mutating func reserve(newCapacity: Int) {
     if !buffer.requestUniqueMutableBuffer(newCapacity) {
       var newBuffer = NativeArrayBuffer<T>(count: count, minimumCapacity: newCapacity)
-      buffer._uninitializedCopy(0...count, target: newBuffer.elementStorage)
+      buffer._uninitializedCopy(0..count, target: newBuffer.elementStorage)
       buffer = Buffer(newBuffer)
     }
     assert(capacity >= newCapacity)
@@ -173,21 +173,21 @@ extension ${Self} : ArrayType {
     assert(count > 0, "can't pop from an empty ${Self}")
     let c = count
     let result = self[c - 1]
-    replace(&self, (c - 1)...c, EmptyCollection())
+    replace(&self, (c - 1)..c, EmptyCollection())
     return result
   }
 
   /// Insert an element at the given index in O(N).  Requires: atIndex
   /// <= count
   mutating func insert(atIndex: Int, newElement: T) {
-    replace(&self, atIndex...atIndex, CollectionOfOne(newElement))
+    replace(&self, atIndex..atIndex, CollectionOfOne(newElement))
   }
 
   /// Remove the element at the given index.  Worst case complexity:
   /// O(N).  Requires: index < count
   mutating func removeAt(index: Int) -> T {
     let result = self[index]
-    replace(&self, index...(index + 1), EmptyCollection())
+    replace(&self, index..(index + 1), EmptyCollection())
     return result
   }
 
@@ -221,7 +221,7 @@ extension ${Self} : ArrayType {
     let count = self.count
     result.reserve(count)
     var p = result.buffer.elementStorage
-    for i in 0...count {
+    for i in 0..count {
       p++.initialize( transform(self[i]) )
     }
     result.buffer.count = count
@@ -356,7 +356,7 @@ func replace<
         elements[j] = newValues[i++]
       }
       // Initialize the hole left by sliding the tail forward
-      for j in oldTailIndex...newTailIndex {
+      for j in oldTailIndex..newTailIndex {
         (elements + j).initialize(newValues[i++])
       }
     }
@@ -535,9 +535,9 @@ func _arrayOutOfPlaceUpdate<
     backing.count = 0
   }
   else {
-    let newStart = source._uninitializedCopy(0...headCount, target: destStart)
+    let newStart = source._uninitializedCopy(0..headCount, target: destStart)
     initializeNewElements.call(newStart)
-    source._uninitializedCopy(headCount + oldCount...sourceCount, 
+    source._uninitializedCopy(headCount + oldCount..sourceCount, 
                               target: newEnd)
   }
   source = Buffer(dest!)

stdlib/core/Collection.swift

@@ -180,12 +180,12 @@ protocol MutableSliceable : Sliceable, MutableCollection {
 }
 
 func dropFirst<Seq : Sliceable>(seq: Seq) -> Seq.SliceType {
-  return seq[seq.startIndex.succ()...seq.endIndex]
+  return seq[seq.startIndex.succ()..seq.endIndex]
 }
 
 func dropLast<
   Seq: Sliceable 
   where Seq.IndexType: BidirectionalIndex
 >(seq: Seq) -> Seq.SliceType {
-  return seq[seq.startIndex...seq.endIndex.pred()]
+  return seq[seq.startIndex..seq.endIndex.pred()]
 }

stdlib/core/Dictionary.swift

@@ -665,7 +665,7 @@ class _NativeDictionaryStorageOwnerBase
         nativeStorage: nativeStorage, offset: Int(theState.extra.0))
     let endIndex = nativeStorage.endIndex
     var stored = 0
-    for i in 0...count {
+    for i in 0..count {
       if (currIndex == endIndex) {
         break
       }
@@ -803,7 +803,7 @@ enum _VariantDictionaryStorage<KeyType : Hashable, ValueType> :
       let newNativeStorage = newNativeOwner.nativeStorage
       let newCapacity = newNativeStorage.capacity
 
-      for i in 0...oldCapacity {
+      for i in 0..oldCapacity {
         var x = oldNativeStorage[i]
         if x {
           if oldCapacity == newCapacity {

stdlib/core/NSSwiftArray.swift

@@ -57,7 +57,7 @@ class NSSwiftArray : HeapBufferStorageBase, CocoaArray {
         count: range.length)
     }
 
-    for i in range.location...range.location + range.length {
+    for i in range.location..range.location + range.length {
       dst++.initialize(reinterpretCast(buffer[i]))
     }
   }

stdlib/core/OutputStream.swift

@@ -66,7 +66,7 @@ func _adHocPrint<T, TargetStream : OutputStream>(
   if mirror is _TupleMirror {
     print("(", &target)
     var first = true
-    for i in 0...mirror.count {
+    for i in 0..mirror.count {
       if first {
         first = false
       } else {

stdlib/core/Process.swift

@@ -17,7 +17,7 @@ struct _Process {
     // FIXME: Use a by-index-initializing constructor of Array here when we
     // have that, so we don't need this awkward closure initialization.
     var _args = new String[Int(C_ARGC)]
-    for i in 0...Int(C_ARGC) {
+    for i in 0..Int(C_ARGC) {
       _args[i] = String.fromCString(C_ARGV[i])
     }
     return _args

stdlib/core/Range.swift

@@ -124,12 +124,12 @@ func count<I: RandomAccessIndex>(r: Range<I>) -> I.DistanceType {
 
 /// \brief Any model of ForwardIndex can be turned into a Range with min...max
 @transparent
-func ... <Pos : ForwardIndex> (min: Pos, max: Pos) -> Range<Pos> {
+func .. <Pos : ForwardIndex> (min: Pos, max: Pos) -> Range<Pos> {
   return Range(start: min, end: max)
 }
 
 @transparent
-func .. <Pos : ForwardIndex> (min: Pos, max: Pos) -> Range<Pos> {
+func ... <Pos : ForwardIndex> (min: Pos, max: Pos) -> Range<Pos> {
   return Range(start: min, end: max.succ())
 }
 

stdlib/core/Reflection.swift

@@ -230,7 +230,7 @@ func _dumpWithMirror<TargetStream : OutputStream>(
   if maxItemCounter <= 0 { return }
   --maxItemCounter
 
-  for _ in 0...indent { print(" ") }
+  for _ in 0..indent { print(" ") }
 
   let count = mirror.count
   let bullet = count == 0    ? "-"
@@ -256,9 +256,9 @@ func _dumpWithMirror<TargetStream : OutputStream>(
 
   if maxDepth <= 0 { return }
 
-  for i in 0...count {
+  for i in 0..count {
     if maxItemCounter <= 0 {
-      for _ in 0...(indent+4) { print(" ") }
+      for _ in 0..(indent+4) { print(" ") }
       let remainder = count - i
       print("(\(remainder)", &targetStream)
       if i > 0 { print(" more", &targetStream) }

stdlib/core/String.swift

@@ -290,6 +290,6 @@ func == (lhs: _Nil, rhs: String) -> Bool { return false }
 extension String : Sliceable {
   subscript(subRange: Range<Index>) -> String {
     return String(
-      unicodeScalars[subRange.startIndex._base...subRange.endIndex._base]._base)
+      unicodeScalars[subRange.startIndex._base..subRange.endIndex._base]._base)
   }
 }

stdlib/core/StringCore.swift

@@ -298,7 +298,7 @@ struct _StringCore {
     }
     else if (hasCocoaBuffer) {
       _StringCore(
-        _cocoaStringToContiguous(source: cocoaBuffer!, range: 0...count, 
+        _cocoaStringToContiguous(source: cocoaBuffer!, range: 0..count, 
                                  minimumCapacity: 0)
       ).encode(encoding, output: output)
     }

stdlib/core/StringLegacy.swift

@@ -31,7 +31,7 @@ extension String {
     self = String(_StringBuffer(capacity: s.core.count * sz, 
                                 initialSize: 0, 
                                 elementWidth: s.core.elementWidth))
-    for i in 0...sz {
+    for i in 0..sz {
       self += s
     }
   }
@@ -86,15 +86,15 @@ extension String {
     while i != end {
       let u8 = utf8[i++]
       if u8 < 0x80 {
-        if 97...123 ~= u8   {
+        if 97..123 ~= u8   {
           resultArray[j++] = u8 - 32
         } else {
           resultArray[j++] = u8
         }
       } else if u8 < 0xE0 {
         resultArray[j++] = u8
         let u8_1 = utf8[i++]
-        if u8 == 0xC3 && 0xA0...0xBF ~= Int(u8_1) && u8_1 != 0xB7 {
+        if u8 == 0xC3 && 0xA0..0xBF ~= Int(u8_1) && u8_1 != 0xB7 {
           resultArray[j++] = u8_1 - 0x20
         } else {
           resultArray[j++] = u8_1
@@ -122,15 +122,15 @@ extension String {
     while i != end {
       let u8 = utf8[i++]
       if u8 < 0x80 {
-        if 65...91 ~= u8   {
+        if 65..91 ~= u8   {
           resultArray[j++] = u8 + 32
         } else {
           resultArray[j++] = u8
         }
       } else if u8 < 0xE0 {
         resultArray[j++] = u8
         let u8_1 = utf8[i++]
-        if u8 == 0xC3 && 0x80...0x9F ~= u8_1 && u8_1 != 0x97 {
+        if u8 == 0xC3 && 0x80..0x9F ~= u8_1 && u8_1 != 0x97 {
           resultArray[j++] = u8_1 + 0x20
         } else {
           resultArray[j++] = u8_1
@@ -311,7 +311,7 @@ extension String {
     // Since Int.min has a larger absolute value, perform addition with
     // negative numbers; detect underflows before they happen. 
     var res : Int = 0
-    for c in scalars[start...scalars.endIndex] {
+    for c in scalars[start..scalars.endIndex] {
       if !c.isDigit() {
         // Conversion failed if a non-digit is encountered.
         return .None
@@ -347,10 +347,10 @@ extension String {
   func substr(start: Int) -> String {
     var rng = unicodeScalars
     var startIndex = rng.startIndex
-    for i in 0...start {
+    for i in 0..start {
       ++startIndex
     }
-    return rng[startIndex...rng.endIndex]
+    return rng[startIndex..rng.endIndex]
   }
 
   /// \brief Split the given string at the given delimiter character, returning 
@@ -362,7 +362,7 @@ extension String {
     var rng = unicodeScalars
     for i in indices(rng) {
       if rng[i] == delim {
-        return (rng[rng.startIndex...i], rng[i.succ()...rng.endIndex], true)
+        return (rng[rng.startIndex..i], rng[i.succ()..rng.endIndex], true)
       }
     }
     return (self, "", false)
@@ -378,7 +378,7 @@ extension String {
     var rng = unicodeScalars
     for i in indices(rng) {
       if pred(rng[i]) {
-        return (rng[rng.startIndex...i], rng[i], rng[i.succ()...rng.endIndex], true)
+        return (rng[rng.startIndex..i], rng[i], rng[i.succ()..rng.endIndex], true)
       }
     }
     return (self, "🎃", String(), false)

stdlib/core/StringUnicodeScalarView.swift

@@ -72,11 +72,11 @@ struct UnicodeScalarView : Sliceable, Sequence {
   }
 
   func __slice__(start: IndexType, end: IndexType) -> UnicodeScalarView {
-    return UnicodeScalarView(_base[start._position...end._position])
+    return UnicodeScalarView(_base[start._position..end._position])
   }
 
   subscript(r: Range<IndexType>) -> UnicodeScalarView {
-    return UnicodeScalarView(_base[r.startIndex._position...r.endIndex._position])
+    return UnicodeScalarView(_base[r.startIndex._position..r.endIndex._position])
   }
 
   struct GeneratorType : Generator {

stdlib/core/Unicode.swift

@@ -249,7 +249,7 @@ extension UTF16 {
         size: UInt(count) * UInt(Builtin.strideof(U.self)))
     }
     else {
-      for i in 0...count {
+      for i in 0..count {
         let u16 = T.toUTF16CodeUnit((source + i).get())
         (destination + i).set(U.fromUTF16CodeUnit(u16))
       }

stdlib/core/UnsafePointer.swift

@@ -121,7 +121,7 @@ struct UnsafePointer<T> : BidirectionalIndex, Comparable, Hashable {
     assert(
       source > self || source < self - count,
       "moveAssignFrom non-following overlapping range")
-    for i in 0...count {
+    for i in 0..count {
       self[i] = (source + i).move()
     }
   }
@@ -132,7 +132,7 @@ struct UnsafePointer<T> : BidirectionalIndex, Comparable, Hashable {
     assert(
       source >= self || source < self - count,
       "moveInitializeFrom non-following overlapping range; use moveInitializeBackwardFrom")
-    for i in 0...count {
+    for i in 0..count {
       (self + i).initialize((source + i).move())
     }
   }
@@ -142,7 +142,7 @@ struct UnsafePointer<T> : BidirectionalIndex, Comparable, Hashable {
     assert(
       source >= self || source < self - count,
       "initializeFrom non-following overlapping range")
-    for i in 0...count {
+    for i in 0..count {
       (self + i).initialize(source[i])
     }
   }