Merge remote-tracking branch 'origin/master' into master-rebranch

Author: swift-ci

docs/SIL.rst

@@ -3484,13 +3484,14 @@ has an escaping function type (not ``[on_stack]``) the closure context will be
 allocated with retain count 1 and initialized to contain the values ``%1``,
 ``%2``, etc.  The closed-over values will not be retained; that must be done
 separately before the ``partial_apply``. The closure does however take ownership
-of the partially applied arguments; when the closure reference count reaches
-zero, the contained values will be destroyed. If the ``partial_apply`` has a
-``@noescape`` function type (``partial_apply [on_stack]``) the closure context
-is allocated on the stack and initialized to contain the closed-over values. The
-closed-over values are not retained, lifetime of the closed-over values must be
-managed separately. The lifetime of the stack context of a ``partial_apply
-[on_stack]`` must be terminated with a ``dealloc_stack``.
+of the partially applied arguments (except for ``@inout_aliasable`` parameters);
+when the closure reference count reaches zero, the contained values will be
+destroyed. If the ``partial_apply`` has a ``@noescape`` function type
+(``partial_apply [on_stack]``) the closure context is allocated on the stack and
+initialized to contain the closed-over values. The closed-over values are not
+retained, lifetime of the closed-over values must be managed separately. The
+lifetime of the stack context of a ``partial_apply [on_stack]`` must be
+terminated with a ``dealloc_stack``.
 
 If the callee is generic, all of its generic parameters must be bound by the
 given substitution list. The arguments are given with these generic
@@ -3499,6 +3500,11 @@ type with the given substitutions applied. The generic parameters themselves
 cannot be partially applied; all of them must be bound. The result is always
 a concrete function.
 
+If an address argument has ``@inout_aliasable`` convention, the closure
+obtained from ``partial_apply`` will not own its underlying value.
+The ``@inout_aliasable`` parameter convention is used when a ``@noescape``
+closure captures an ``inout`` argument.
+
 TODO: The instruction, when applied to a generic function,
 currently implicitly performs abstraction difference transformations enabled
 by the given substitutions, such as promoting address-only arguments and returns

stdlib/public/core/Diffing.swift

@@ -15,8 +15,8 @@
 @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
 extension CollectionDifference {
   fileprivate func _fastEnumeratedApply(
-    _ consume: (Change) -> Void
-  ) {
+    _ consume: (Change) throws -> Void
+  ) rethrows {
     let totalRemoves = removals.count
     let totalInserts = insertions.count
     var enumeratedRemoves = 0
@@ -41,7 +41,7 @@ extension CollectionDifference {
         preconditionFailure()
       }
 
-      consume(change)
+      try consume(change)
 
       switch change {
       case .remove(_, _, _):
@@ -53,6 +53,9 @@ extension CollectionDifference {
   }
 }
 
+// Error type allows the use of throw to unroll state on application failure
+private enum _ApplicationError : Error { case failed }
+
 extension RangeReplaceableCollection {
   /// Applies the given difference to this collection.
   ///
@@ -66,45 +69,54 @@ extension RangeReplaceableCollection {
   ///   number of changes contained by the parameter.
   @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
   public func applying(_ difference: CollectionDifference<Element>) -> Self? {
-    var result = Self()
-    var enumeratedRemoves = 0
-    var enumeratedInserts = 0
-    var enumeratedOriginals = 0
-    var currentIndex = self.startIndex
 
     func append(
       into target: inout Self,
       contentsOf source: Self,
       from index: inout Self.Index, count: Int
-    ) {
+    ) throws {
       let start = index
-      source.formIndex(&index, offsetBy: count)
+      if !source.formIndex(&index, offsetBy: count, limitedBy: source.endIndex) {
+        throw _ApplicationError.failed
+      }
       target.append(contentsOf: source[start..<index])
     }
 
-    difference._fastEnumeratedApply { change in
-      switch change {
-      case .remove(offset: let offset, element: _, associatedWith: _):
-        let origCount = offset - enumeratedOriginals
-        append(into: &result, contentsOf: self, from: &currentIndex, count: origCount)
-        enumeratedOriginals += origCount + 1 // Removal consumes an original element
-        currentIndex = self.index(after: currentIndex)
-        enumeratedRemoves += 1
-      case .insert(offset: let offset, element: let element, associatedWith: _):
-        let origCount = (offset + enumeratedRemoves - enumeratedInserts) - enumeratedOriginals
-        append(into: &result, contentsOf: self, from: &currentIndex, count: origCount)
-        result.append(element)
-        enumeratedOriginals += origCount
-        enumeratedInserts += 1
+    var result = Self()
+    do {
+      var enumeratedRemoves = 0
+      var enumeratedInserts = 0
+      var enumeratedOriginals = 0
+      var currentIndex = self.startIndex
+      try difference._fastEnumeratedApply { change in
+        switch change {
+        case .remove(offset: let offset, element: _, associatedWith: _):
+          let origCount = offset - enumeratedOriginals
+          try append(into: &result, contentsOf: self, from: &currentIndex, count: origCount)
+          if currentIndex == self.endIndex {
+            // Removing nonexistent element off the end of the collection
+            throw _ApplicationError.failed
+          }
+          enumeratedOriginals += origCount + 1 // Removal consumes an original element
+          currentIndex = self.index(after: currentIndex)
+          enumeratedRemoves += 1
+        case .insert(offset: let offset, element: let element, associatedWith: _):
+          let origCount = (offset + enumeratedRemoves - enumeratedInserts) - enumeratedOriginals
+          try append(into: &result, contentsOf: self, from: &currentIndex, count: origCount)
+          result.append(element)
+          enumeratedOriginals += origCount
+          enumeratedInserts += 1
+        }
+        _internalInvariant(enumeratedOriginals <= self.count)
+      }
+      if currentIndex < self.endIndex {
+        result.append(contentsOf: self[currentIndex...])
       }
-      _internalInvariant(enumeratedOriginals <= self.count)
+      _internalInvariant(result.count == self.count + enumeratedInserts - enumeratedRemoves)
+    } catch {
+      return nil
     }
-    let origCount = self.count - enumeratedOriginals
-    append(into: &result, contentsOf: self, from: &currentIndex, count: origCount)
 
-    _internalInvariant(currentIndex == self.endIndex)
-    _internalInvariant(enumeratedOriginals + origCount == self.count)
-    _internalInvariant(result.count == self.count + enumeratedInserts - enumeratedRemoves)
     return result
   }
 }

test/stdlib/Diffing.swift

@@ -629,6 +629,68 @@ if #available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *) {
               }}}}}}
   }
 
+  suite.test("Fast applicator error condition") {
+    let bear = "bear"
+    let bird = "bird"
+    let bat = "bat"
+
+    let diff = bird.difference(from: bear)
+
+    expectEqual(nil, bat.applying(diff))
+  }
+
+  suite.test("Fast applicator boundary condition remove last element") {
+    let base = [1, 2, 3]
+
+    expectEqual([1, 2], base.applying(CollectionDifference<Int>([.remove(offset: base.count - 1, element: 3, associatedWith: nil)])!))
+  }
+
+  suite.test("Fast applicator boundary condition append element") {
+    let base = [1, 2, 3]
+
+    expectEqual([1, 2, 3, 4], base.applying(CollectionDifference<Int>([.insert(offset: base.count, element: 4, associatedWith: nil)])!))
+  }
+
+  suite.test("Fast applicator error boundary condition remove at endIndex") {
+    let base = [1, 2, 3]
+
+    expectEqual(nil, base.applying(CollectionDifference<Int>([.remove(offset: base.count, element: 4, associatedWith: nil)])!))
+  }
+
+  suite.test("Fast applicator error boundary condition insert beyond end") {
+    let base = [1, 2, 3]
+
+    expectEqual(nil, base.applying(CollectionDifference<Int>([.insert(offset: base.count + 1, element: 5, associatedWith: nil)])!))
+  }
+
+  suite.test("Fast applicator boundary condition replace tail") {
+    let base = [1, 2, 3]
+
+    expectEqual([1, 2, 4], base.applying(CollectionDifference<Int>([
+      .remove(offset: base.count - 1, element: 3, associatedWith: nil),
+      .insert(offset: base.count - 1, element: 4, associatedWith: nil)
+    ])!))
+  }
+
+  suite.test("Fast applicator error boundary condition insert beyond end after tail removal") {
+    let base = [1, 2, 3]
+
+    expectEqual(nil, base.applying(CollectionDifference<Int>([
+      .remove(offset: base.count - 1, element: 3, associatedWith: nil),
+      .insert(offset: base.count, element: 4, associatedWith: nil)
+    ])!))
+
+  }
+
+  suite.test("Fast applicator error boundary condition insert beyond end after non-tail removal") {
+    let base = [1, 2, 3]
+
+    expectEqual(nil, base.applying(CollectionDifference<Int>([
+      .remove(offset: base.count - 2, element: 2, associatedWith: nil),
+      .insert(offset: base.count, element: 4, associatedWith: nil)
+    ])!))
+  }
+
   suite.test("Fast applicator fuzzer") {
     func makeArray() -> [Int] {
       var arr = [Int]()