Move += operator for append(contentsOf:) up to RangeReplaceableCollection

Author: airspeedswift

stdlib/public/core/ArrayType.swift

@@ -43,10 +43,6 @@ internal protocol _ArrayProtocol
   /// - Complexity: O(`self.count`).
   mutating func reserveCapacity(_ minimumCapacity: Int)
 
-  /// Operator form of `append(contentsOf:)`.
-  static func += <S : Sequence>(lhs: inout Self, rhs: S)
-    where S.Iterator.Element == Iterator.Element
-
   /// Insert `newElement` at index `i`.
   ///
   /// Invalidates all indices with respect to `self`.

stdlib/public/core/Arrays.swift.gyb

@@ -1739,30 +1739,6 @@ extension ${Self} {
     }
   }
 }
-
-// FIXME(ABI)#16 : remove this entrypoint.  The functionality should be provided by
-// a `+=` operator on `RangeReplaceableCollection`.
-/// Appends the elements of a sequence to ${a_Self}.
-///
-/// Use this operator to append the elements of a sequence to the end of
-/// ${a_Self} with same `Element` type. This example appends
-/// the elements of a `Range<Int>` instance to an array of integers.
-///
-///     var numbers = [1, 2, 3, 4, 5]
-///     numbers += 10...15
-///     print(numbers)
-///     // Prints "[1, 2, 3, 4, 5, 10, 11, 12, 13, 14, 15]"
-///
-/// - Parameters:
-///   - lhs: The array to append to.
-///   - rhs: A collection or finite sequence.
-///
-/// - Complexity: O(*n*), where *n* is the length of the resulting array.
-public func += <
-  S : Sequence
->(lhs: inout ${Self}<S.Iterator.Element>, rhs: S) {
-  lhs.append(contentsOf: rhs)
-}
 % end
 
 //===--- generic helpers --------------------------------------------------===//

stdlib/public/core/RangeReplaceableCollection.swift.gyb

@@ -294,26 +294,6 @@ public protocol RangeReplaceableCollection
     with newElements: C
   ) where C : Collection, C.Iterator.Element == Iterator.Element
 
-  /*
-  We could have these operators with default implementations, but the compiler
-  crashes:
-
-  <rdar://problem/16566712> Dependent type should have been substituted by Sema
-  or SILGen
-
-  func + <S : Sequence>(_: Self, _: S) -> Self
-    where S.Iterator.Element == Iterator.Element
-
-  func + <S : Sequence>(_: S, _: Self) -> Self
-    where S.Iterator.Element == Iterator.Element
-
-  func + <S : Collection>(_: Self, _: S) -> Self
-    where S.Iterator.Element == Iterator.Element
-
-  func + <RC : RangeReplaceableCollection>(_: Self, _: S) -> Self
-    where RC.Iterator.Element == Iterator.Element
-  */
-
   /// Prepares the collection to store the specified number of elements, when
   /// doing so is appropriate for the underlying type.
   ///
@@ -370,16 +350,6 @@ public protocol RangeReplaceableCollection
   ///   collection.
   mutating func append(_ newElement: Iterator.Element)
 
-  /*
-  The 'append(contentsOf:)' requirement should be an operator, but the compiler crashes:
-
-  <rdar://problem/16566712> Dependent type should have been substituted by Sema
-  or SILGen
-
-  func += <S : Sequence>(inout _: Self, _: S)
-    where S.Iterator.Element == Iterator.Element
-  */
-
   /// Adds the elements of a sequence or collection to the end of this
   /// collection.
   ///
@@ -398,6 +368,8 @@ public protocol RangeReplaceableCollection
   ///
   /// - Complexity: O(*n*), where *n* is the length of the resulting
   ///   collection.
+  // FIXME(ABI)#166 (Evolution): Consider replacing .append(contentsOf) with +=
+  // suggestion in SE-91
   mutating func append<S : Sequence>(contentsOf newElements: S)
     where S.Iterator.Element == Iterator.Element
 
@@ -1171,6 +1143,29 @@ public func +<
   return lhs
 }
 
+/// Appends the elements of a sequence to a range-replaceable collection.
+///
+/// Use this operator to append the elements of a sequence to the end of
+/// range-replaceable collection with same `Element` type. This example appends
+/// the elements of a `Range<Int>` instance to an array of integers.
+///
+///     var numbers = [1, 2, 3, 4, 5]
+///     numbers += 10...15
+///     print(numbers)
+///     // Prints "[1, 2, 3, 4, 5, 10, 11, 12, 13, 14, 15]"
+///
+/// - Parameters:
+///   - lhs: The array to append to.
+///   - rhs: A collection or finite sequence.
+///
+/// - Complexity: O(*n*), where *n* is the length of the resulting array.
+public func += <
+  R : RangeReplaceableCollection, S : Sequence
+>(lhs: inout R, rhs: S) 
+ where R.Iterator.Element == S.Iterator.Element {
+  lhs.append(contentsOf: rhs)
+}
+
 @available(*, unavailable, renamed: "RangeReplaceableCollection")
 public typealias RangeReplaceableCollectionType = RangeReplaceableCollection
 

test/Misc/misc_diagnostics.swift

@@ -99,11 +99,11 @@ func test17875634() {
   var col = 2
   var coord = (row, col)
 
-  match += (1, 2) // expected-error{{binary operator '+=' cannot be applied to operands of type '[(Int, Int)]' and '(Int, Int)'}} expected-note {{overloads for '+=' exist}}
+  match += (1, 2) // expected-error{{argument type '(Int, Int)' does not conform to expected type 'Sequence'}}
 
-  match += (row, col) // expected-error{{binary operator '+=' cannot be applied to operands of type '[(Int, Int)]' and '(Int, Int)'}} expected-note {{overloads for '+=' exist}}
+  match += (row, col) // expected-error{{argument type '(@lvalue Int, @lvalue Int)' does not conform to expected type 'Sequence'}}
 
-  match += coord // expected-error{{binary operator '+=' cannot be applied to operands of type '[(Int, Int)]' and '(Int, Int)'}} expected-note {{overloads for '+=' exist}}
+  match += coord // expected-error{{argument type '@lvalue (Int, Int)' does not conform to expected type 'Sequence'}}
 
   match.append(row, col) // expected-error{{extra argument in call}}