stdlib: rename RangeReplaceableCollectionType.extend() to appendContentsOf()

rdar://21972324

Swift SVN r30607

stdlib/private/StdlibUnittest/CheckRangeReplaceableCollectionType.swift

@@ -396,10 +396,10 @@ self.test("\(testNamePrefix).append()/semantics") {
 }
 
 //===----------------------------------------------------------------------===//
-// extend()
+// appendContentsOf()
 //===----------------------------------------------------------------------===//
 
-self.test("\(testNamePrefix).extend()/semantics") {
+self.test("\(testNamePrefix).appendContentsOf()/semantics") {
   let tests: [ExtendTest] = [
     ExtendTest(
       collection: [],
@@ -441,7 +441,7 @@ self.test("\(testNamePrefix).extend()/semantics") {
     var c = makeWrappedCollection(test.collection)
     let newElements =
       MinimalForwardCollection(test.newElements.map(wrapValue))
-    c.extend(newElements)
+    c.appendContentsOf(newElements)
     expectEqualSequence(
       test.expected,
       c.map { extractValue($0).value },

stdlib/private/StdlibUnittest/LoggingWrappers.swift.gyb

@@ -62,7 +62,7 @@ public struct LoggingGenerator<Base: GeneratorType>
 /// Each static variable is a mapping of Type -> Number of calls.
 public class RangeReplaceableCollectionLog {
   public static var append = TypeIndexed(0)
-  public static var extend = TypeIndexed(0)
+  public static var appendContentsOf = TypeIndexed(0)
   public static var insert = TypeIndexed(0)
   public static var removeAll = TypeIndexed(0)
   public static var removeAtIndex = TypeIndexed(0)
@@ -140,11 +140,11 @@ public struct LoggingRangeReplaceableCollection<
     base.append(newElement)
   }
 
-  public mutating func extend<
+  public mutating func appendContentsOf<
     S : SequenceType where S.Generator.Element == Base.Generator.Element
   >(newElements: S) {
-    ++Log.extend[selfType]
+    ++Log.appendContentsOf[selfType]
-    base.extend(newElements)
+    base.appendContentsOf(newElements)
   }
 
   public mutating func insert(

stdlib/private/StdlibUnittest/RaceTest.swift

@@ -418,12 +418,12 @@ func _masterThreadOneTrial<RT : RaceTestWithPerTrialDataType>(
   let rt = RT()
 
   sharedState.raceData.removeAll(keepCapacity: true)
-  sharedState.raceData.extend(
+  sharedState.raceData.appendContentsOf(
     lazy(0..<raceDataCount).map { i in rt.makeRaceData() })
 
   let identityShuffle = Array(0..<sharedState.raceData.count)
   sharedState.workerStates.removeAll(keepCapacity: true)
-  sharedState.workerStates.extend(
+  sharedState.workerStates.appendContentsOf(
     lazy(0..<racingThreadCount).map {
       i in
       let workerState = _RaceTestWorkerState<RT>()

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -3131,11 +3131,11 @@ public struct ${Self}<T> : RangeReplaceableCollectionType {
     elements.append(x)
   }
 
-  public mutating func extend<
+  public mutating func appendContentsOf<
     S : SequenceType where S.Generator.Element == T
   >(newElements: S) {
     _willMutate()
-    elements.extend(newElements)
+    elements.appendContentsOf(newElements)
   }
 
   public mutating func replaceRange<

stdlib/private/SwiftPrivate/SwiftPrivate.swift

@@ -81,7 +81,7 @@ public func withArrayOfCStrings<R>(
   var argsBuffer: [UInt8] = []
   argsBuffer.reserveCapacity(argsBufferSize)
   for arg in args {
-    argsBuffer.extend(arg.utf8)
+    argsBuffer.appendContentsOf(arg.utf8)
     argsBuffer.append(0)
   }
 

stdlib/public/core/ArrayType.swift

@@ -48,7 +48,7 @@ protocol _ArrayType
   /// - Complexity: O(`count`).
   mutating func reserveCapacity(minimumCapacity: Int)
 
-  /// Operator form of `extend`.
+  /// Operator form of `appendContentsOf`.
   func += <
     S: SequenceType where S.Generator.Element == Generator.Element
   >(inout lhs: Self, rhs: S)

stdlib/public/core/Arrays.swift.gyb

@@ -569,19 +569,19 @@ extension ${Self} : _ArrayType {
   /// Append the elements of `newElements` to `self`.
   ///
   /// - Complexity: O(*length of result*).
-  public mutating func extend<
+  public mutating func appendContentsOf<
       S : SequenceType
       where S.Generator.Element == Element
   >(newElements: S) {
     self += newElements
   }
 
-  // An overload of extend that uses the += that is optimized for
+  // An overload of `appendContentsOf()` that uses the += that is optimized for
   // collections.
   /// Append the elements of `newElements` to `self`.
   ///
   /// - Complexity: O(*length of result*).
-  public mutating func extend<
+  public mutating func appendContentsOf<
       C : CollectionType
       where C.Generator.Element == Element
   >(newElements: C) {

stdlib/public/core/Character.swift

@@ -110,7 +110,7 @@ public struct Character :
         return
       }
       var nativeString = ""
-      nativeString.extend(s)
+      nativeString.appendContentsOf(s)
       _representation = .Large(nativeString._core.nativeBuffer!._storage)
     }
   }

stdlib/public/core/Join.swift

@@ -41,15 +41,15 @@ public func join<
   if separatorSize != 0 {
     var gen = elements.generate()
     if let first = gen.next() {
-      result.extend(first)
+      result.appendContentsOf(first)
       while let next = gen.next() {
-        result.extend(separator)
+        result.appendContentsOf(separator)
-        result.extend(next)
+        result.appendContentsOf(next)
       }
     }
   } else {
     for x in elements {
-      result.extend(x)
+      result.appendContentsOf(x)
     }
   }
 

stdlib/public/core/RangeReplaceableCollectionType.swift

@@ -82,7 +82,7 @@ public protocol RangeReplaceableCollectionType : CollectionType {
   mutating func append(x: Generator.Element)
 
   /*
-  The 'extend' requirement should be an operator, but the compiler crashes:
+  The 'appendContentsOf' requirement should be an operator, but the compiler crashes:
 
   <rdar://problem/16566712> Dependent type should have been substituted by Sema
   or SILGen
@@ -96,7 +96,7 @@ public protocol RangeReplaceableCollectionType : CollectionType {
   /// Append the elements of `newElements` to `self`.
   ///
   /// - Complexity: O(*length of result*).
-  mutating func extend<
+  mutating func appendContentsOf<
     S : SequenceType
     where S.Generator.Element == Generator.Element
   >(newElements: S)
@@ -167,7 +167,7 @@ extension RangeReplaceableCollectionType {
     insert(newElement, atIndex: endIndex)
   }
 
-  public mutating func extend<
+  public mutating func appendContentsOf<
     S : SequenceType where S.Generator.Element == Generator.Element
   >(newElements: S) {
     for element in newElements {
@@ -311,7 +311,7 @@ public func removeAll<
 /// Append elements from `newElements` to `x`.
 ///
 /// - Complexity: O(N).
-@available(*, unavailable, message="call the 'extend()' method on the collection")
+@available(*, unavailable, message="call the 'appendContentsOf()' method on the collection")
 public func extend<
     C: RangeReplaceableCollectionType,
     S : SequenceType where S.Generator.Element == C.Generator.Element
@@ -335,7 +335,7 @@ public func +<
     where S.Generator.Element == C.Generator.Element
 >(var lhs: C, rhs: S) -> C {
   // FIXME: what if lhs is a reference type?  This will mutate it.
-  lhs.extend(rhs)
+  lhs.appendContentsOf(rhs)
   return lhs
 }
 
@@ -346,8 +346,8 @@ public func +<
 >(lhs: S, rhs: C) -> C {
   var result = C()
   result.reserveCapacity(rhs.count + numericCast(rhs.underestimateCount()))
-  result.extend(lhs)
+  result.appendContentsOf(lhs)
-  result.extend(rhs)
+  result.appendContentsOf(rhs)
   return result
 }
 
@@ -358,7 +358,7 @@ public func +<
 >(var lhs: C, rhs: S) -> C {
   // FIXME: what if lhs is a reference type?  This will mutate it.
   lhs.reserveCapacity(lhs.count + numericCast(rhs.count))
-  lhs.extend(rhs)
+  lhs.appendContentsOf(rhs)
   return lhs
 }
 
@@ -369,7 +369,7 @@ public func +<
 >(var lhs: RRC1, rhs: RRC2) -> RRC1 {
   // FIXME: what if lhs is a reference type?  This will mutate it.
   lhs.reserveCapacity(lhs.count + numericCast(rhs.count))
-  lhs.extend(rhs)
+  lhs.appendContentsOf(rhs)
   return lhs
 }
 

stdlib/public/core/SequenceAlgorithms.swift.gyb

@@ -388,7 +388,7 @@ extension SequenceType {
   ) -> [S.${GElement}] {
     var result: [S.${GElement}] = []
     for element in self {
-      result.extend(transform(element))
+      result.appendContentsOf(transform(element))
     }
     return result
   }

stdlib/public/core/String.swift

@@ -50,7 +50,7 @@ import SwiftShims
 ///
 ///     var a = "foo"
 ///     var b = a
-///     b.extend("bar")
+///     b.appendContentsOf("bar")
 ///     print("a=\(a), b=\(b)")     // a=foo, b=foobar
 ///
 /// Strings use Copy-on-Write so that their data is only copied
@@ -414,7 +414,7 @@ public func <(lhs: String, rhs: String) -> Bool {
 extension String {
 
   /// Append the elements of `other` to `self`.
-  public mutating func extend(other: String) {
+  public mutating func appendContentsOf(other: String) {
     _core.append(other._core)
   }
 
@@ -573,11 +573,13 @@ extension String {
     }
   }
   
-  public mutating func extend<
+  public mutating func appendContentsOf<
       S : SequenceType
   where S.Generator.Element == Character
   >(newElements: S) {
-    withMutableCharacters { (inout v: CharacterView) in v.extend(newElements) }
+    withMutableCharacters {
+      (inout v: CharacterView) in v.appendContentsOf(newElements)
+    }
   }
   
   /// Create an instance containing `characters`.

stdlib/public/core/StringCharacterView.swift

@@ -294,14 +294,14 @@ extension String.CharacterView : RangeReplaceableCollectionType {
     switch c._representation {
     case .Small(let _63bits):
       let bytes = Character._smallValue(_63bits)
-      _core.extend(Character._SmallUTF16(bytes))
+      _core.appendContentsOf(Character._SmallUTF16(bytes))
     case .Large(_):
       _core.append(String(c)._core)
     }
   }
 
   /// Append the elements of `newElements` to `self`.
-  public mutating func extend<
+  public mutating func appendContentsOf<
       S : SequenceType
       where S.Generator.Element == Character
   >(newElements: S) {
@@ -317,7 +317,7 @@ extension String.CharacterView : RangeReplaceableCollectionType {
       where S.Generator.Element == Character
   >(_ characters: S) {
     self = String.CharacterView()
-    self.extend(characters)
+    self.appendContentsOf(characters)
   }
 }
 

stdlib/public/core/StringCore.swift

@@ -638,9 +638,9 @@ extension _StringCore : RangeReplaceableCollectionType {
             : representableAsASCII() && !newElements.contains { $0 > 0x7f } ? 1
             : 2
         ))
-      r.extend(self[0..<subRange.startIndex])
+      r.appendContentsOf(self[0..<subRange.startIndex])
-      r.extend(newElements)
+      r.appendContentsOf(newElements)
-      r.extend(self[subRange.endIndex..<count])
+      r.appendContentsOf(self[subRange.endIndex..<count])
       self = r
     }
   }
@@ -660,7 +660,7 @@ extension _StringCore : RangeReplaceableCollectionType {
     _copyInPlace(newSize: count, newCapacity: max(count, n), minElementWidth: 1)
   }
 
-  public mutating func extend<
+  public mutating func appendContentsOf<
     S : SequenceType
       where S.Generator.Element == UTF16.CodeUnit
   >(s: S) {

stdlib/public/core/StringUnicodeScalarView.swift

@@ -264,10 +264,10 @@ extension String.UnicodeScalarView : RangeReplaceableCollectionType {
   /// Append the elements of `newElements` to `self`.
   ///
   /// - Complexity: O(*length of result*).
-  public mutating func extend<
+  public mutating func appendContentsOf<
     S : SequenceType where S.Generator.Element == UnicodeScalar
   >(newElements: S) {
-    _core.extend(newElements._prext_lazy.flatMap { $0.utf16 })
+    _core.appendContentsOf(newElements._prext_lazy.flatMap { $0.utf16 })
   }
   /// Replace the given `subRange` of elements with `newElements`.
   ///

test/1_stdlib/RangeReplaceable.swift.gyb

@@ -15,10 +15,10 @@ RangeReplaceableTestSuite.test("append/dispatch") {
   expectCustomizable(tester, tester.log.append)
 }
 
-RangeReplaceableTestSuite.test("extend/dispatch") {
+RangeReplaceableTestSuite.test("appendContentsOf/dispatch") {
   var tester = RangeReplaceableCollectionLog.dispatchTester([ OpaqueValue(1) ])
-  tester.extend([ 2, 3 ].map(OpaqueValue.init))
+  tester.appendContentsOf([ 2, 3 ].map(OpaqueValue.init))
-  expectCustomizable(tester, tester.log.extend)
+  expectCustomizable(tester, tester.log.appendContentsOf)
 }
 
 RangeReplaceableTestSuite.test("insert/dispatch") {

test/IDE/complete_literal.swift

@@ -44,7 +44,7 @@
 // LITERAL4-DAG:     Decl[InstanceVar]/CurrNominal:      startIndex[#Index#]; name=startIndex{{$}}
 // LITERAL4-DAG:     Decl[InstanceVar]/CurrNominal:      endIndex[#Index#]; name=endIndex{{$}}
 // LITERAL4-DAG:     Decl[InstanceMethod]/CurrNominal:   append({#(c): Character#})[#Void#]; name=append(c: Character){{$}}
-// LITERAL4-DAG:     Decl[InstanceMethod]/CurrNominal:   extend({#(newElements): S#})[#Void#]; name=extend(newElements: S){{$}}
+// LITERAL4-DAG:     Decl[InstanceMethod]/CurrNominal:   appendContentsOf({#(newElements): S#})[#Void#]; name=appendContentsOf(newElements: S){{$}}
 // LITERAL4-DAG:     Decl[InstanceMethod]/CurrNominal:   splice({#(newElements): S#}, {#atIndex: Index#})[#Void#]; name=splice(newElements: S, atIndex: Index){{$}}
 // LITERAL4-DAG:     Decl[InstanceMethod]/CurrNominal:   removeAtIndex({#(i): Index#})[#Character#]; name=removeAtIndex(i: Index){{$}}
 // LITERAL4-DAG:     Decl[InstanceVar]/CurrNominal:      lowercaseString[#String#]; name=lowercaseString{{$}}

test/Interpreter/algorithms.swift

@@ -28,7 +28,7 @@ func flatten<Element, Sequence: SequenceType, InnerSequence: SequenceType
   var result = [Element]()
 
   for innerSequence in outerSequence {
-    result.extend(innerSequence)
+    result.appendContentsOf(innerSequence)
   }
 
   return result

test/expr/expressions.swift

@@ -423,7 +423,7 @@ func stringliterals() {
 
 // <rdar://problem/17128913>
 var s = ""
-s.extend(["x"])
+s.appendContentsOf(["x"])
 
 //===----------------------------------------------------------------------===//
 // InOut arguments

validation-test/stdlib/StdlibUnittestSequencesCollections.swift.gyb

@@ -87,21 +87,21 @@ ${Self}TestSuite.test("append()/IndexInvalidation/DifferentMutationEpoch") {
   }
 }
 
-${Self}TestSuite.test("extend()/IndexInvalidation/DifferentBuffer") {
+${Self}TestSuite.test("appendContentsOf()/IndexInvalidation/DifferentBuffer") {
   var c1 = ${Self}([ 1010, 2020, 3030 ].map(OpaqueValue.init))
   let c2 = c1
   let i = c1.startIndex
-  c1.extend([ 4040, 5050 ].map(OpaqueValue.init))
+  c1.appendContentsOf([ 4040, 5050 ].map(OpaqueValue.init))
   expectFailure {
     _ = i == c1.startIndex
   }
   _blackHole(c2)
 }
 
-${Self}TestSuite.test("extend()/IndexInvalidation/DifferentMutationEpoch") {
+${Self}TestSuite.test("appendContentsOf()/IndexInvalidation/DifferentMutationEpoch") {
   var c = ${Self}([ 1010, 2020, 3030 ].map(OpaqueValue.init))
   let i = c.startIndex
-  c.extend([ 4040, 5050 ].map(OpaqueValue.init))
+  c.appendContentsOf([ 4040, 5050 ].map(OpaqueValue.init))
   expectFailure {
     _ = i == c.startIndex
   }

validation-test/stdlib/String.swift

@@ -595,7 +595,7 @@ func asciiString<
   S: SequenceType where S.Generator.Element == Character
 >(content: S) -> String {
   var s = String()
-  s.extend(content)
+  s.appendContentsOf(content)
   expectEqual(1, s._core.elementWidth)
   return s
 }
@@ -617,11 +617,11 @@ StringTests.test("stringCoreExtensibility") {
         if k == 0 { expectEqual(1, x.elementWidth) }
         
         for i in 0..<length {
-          x.extend(
+          x.appendContentsOf(
             Repeat(count: 3, repeatedValue: i < boundary ? ascii : nonAscii))
         }
-        // Make sure we can extend wide storage with pure ASCII
+        // Make sure we can append pure ASCII to wide storage
-        x.extend(Repeat(count: 2, repeatedValue: ascii))
+        x.appendContentsOf(Repeat(count: 2, repeatedValue: ascii))
         
         expectEqualSequence(
           [UTF16.CodeUnit(UnicodeScalar("b").value)]
@@ -696,7 +696,7 @@ func makeStringCore(base: String) -> _StringCore {
   var x = _StringCore()
   // make sure some - but not all - replacements will have to grow the buffer
   x.reserveCapacity(base._core.count * 3 / 2)
-  x.extend(base._core)
+  x.appendContentsOf(base._core)
   // In case the core was widened and lost its capacity
   x.reserveCapacity(base._core.count * 3 / 2)
   return x

validation-test/stdlib/StringSlicesConcurrentAppend.swift

@@ -44,7 +44,7 @@ func sliceConcurrentAppendThread(tid: ThreadID) {
     if tid == .Master {
       // Get a fresh buffer.
       sharedString = ""
-      sharedString.extend("abc")
+      sharedString.appendContentsOf("abc")
       sharedString.reserveCapacity(16)
       expectLE(16, sharedString.capacityInBytes)
     }
@@ -58,9 +58,9 @@ func sliceConcurrentAppendThread(tid: ThreadID) {
 
     // Append to the private string.
     if tid == .Master {
-      privateString.extend("def")
+      privateString.appendContentsOf("def")
     } else {
-      privateString.extend("ghi")
+      privateString.appendContentsOf("ghi")
     }
 
     barrier()