Replace rethrowing map with generic typed throws

Adopt typed throws for the `map` operation to propagate thrown error
types through the `map` API. This is done in a manner that is backward
compatible for almost all cases:

* The new typed-throws entrypoint is `@_alwaysEmitIntoClient` so it
can back-deploy all the way back.
* The old `rethrows` entrypoint is left in place, using
`@usableFromInline` with `internal` so it is part of the ABI but not
the public interface, and `@_disfavoredOverload` so the type checker
avoids it while building the standard library itself. The old
entrypoint is implemented in terms of the new one.

Note that the implementation details for the existential collection
"box" classes rely on method overriding of `_map` operations, and the
types are frozen, so  we don't get to change their signatures. However,
these are only implementations, not API: the actual API `map`
functions can be upgraded to typed throws.

Note that this code makes use of a known hole in `rethrows` checking
to allow calling between `rethrows` and typed throws. We'll need to do
something about this for source-compatibility reasons, but I'll follow
up with that separately.

Author: DougGregor

stdlib/public/core/Collection.swift

@@ -1190,9 +1190,10 @@ extension Collection {
   /// - Returns: An array containing the transformed elements of this
   ///   sequence.
   @inlinable
-  public func map<T>(
-    _ transform: (Element) throws -> T
-  ) rethrows -> [T] {
+  @_alwaysEmitIntoClient
+  public func map<T, E>(
+    _ transform: (Element) throws(E) -> T
+  ) throws(E) -> [T] {
     // TODO: swift-3-indexing-model - review the following
     let n = self.count
     if n == 0 {
@@ -1213,6 +1214,20 @@ extension Collection {
     return Array(result)
   }
 
+  // ABI-only entrypoint
+  @usableFromInline
+  @_disfavoredOverload
+  func map<T>(
+    _ transform: (Element) throws -> T
+  ) rethrows -> [T] {
+    do {
+      return try map(transform)
+    } catch {
+      try _rethrowsViaClosure { throw error }
+      Builtin.unreachable()
+    }
+  }
+
   /// Returns a subsequence containing all but the given number of initial
   /// elements.
   ///

stdlib/public/core/ExistentialCollection.swift

@@ -526,7 +526,12 @@ internal final class _SequenceBox<S: Sequence>: _AnySequenceBox<S.Element> {
   internal override func _map<T>(
     _ transform: (Element) throws -> T
   ) rethrows -> [T] {
-    return try _base.map(transform)
+    do {
+      return try _base.map(transform)
+    } catch {
+      try _rethrowsViaClosure { throw error }
+      Builtin.unreachable()
+    }
   }
   @inlinable
   internal override func _filter(
@@ -619,7 +624,12 @@ internal final class _CollectionBox<S: Collection>: _AnyCollectionBox<S.Element>
   internal override func _map<T>(
     _ transform: (Element) throws -> T
   ) rethrows -> [T] {
-    return try _base.map(transform)
+    do {
+      return try _base.map(transform)
+    } catch {
+      try _rethrowsViaClosure { throw error }
+      Builtin.unreachable()
+    }
   }
   @inlinable
   internal override func _filter(
@@ -814,7 +824,12 @@ internal final class _BidirectionalCollectionBox<S: BidirectionalCollection>
   internal override func _map<T>(
     _ transform: (Element) throws -> T
   ) rethrows -> [T] {
-    return try _base.map(transform)
+    do {
+      return try _base.map(transform)
+    } catch {
+      try _rethrowsViaClosure { throw error }
+      Builtin.unreachable()
+    }
   }
   @inlinable
   internal override func _filter(
@@ -1027,7 +1042,12 @@ internal final class _RandomAccessCollectionBox<S: RandomAccessCollection>
   internal override func _map<T>(
     _ transform: (Element) throws -> T
   ) rethrows -> [T] {
-    return try _base.map(transform)
+    do {
+      return try _base.map(transform)
+    } catch {
+      try _rethrowsViaClosure { throw error }
+      Builtin.unreachable()
+    }
   }
   @inlinable
   internal override func _filter(
@@ -1308,10 +1328,29 @@ extension AnySequence {
   }
 
   @inlinable
-  public func map<T>(
+  @_alwaysEmitIntoClient
+  public func map<T, E>(
+    _ transform: (Element) throws(E) -> T
+  ) throws(E) -> [T] {
+    do {
+      return try _box._map(transform)
+    } catch {
+      throw error as! E
+    }
+  }
+
+  // ABI-only entrypoint
+  @usableFromInline
+  @_disfavoredOverload
+  func map<T>(
     _ transform: (Element) throws -> T
   ) rethrows -> [T] {
-    return try _box._map(transform)
+    do {
+      return try map(transform)
+    } catch {
+      try _rethrowsViaClosure { throw error }
+      Builtin.unreachable()
+    }
   }
 
   @inlinable
@@ -1395,10 +1434,29 @@ extension AnyCollection {
   }
 
   @inlinable
-  public func map<T>(
+  @_alwaysEmitIntoClient
+  public func map<T, E>(
+    _ transform: (Element) throws(E) -> T
+  ) throws(E) -> [T] {
+    do {
+      return try _box._map(transform)
+    } catch {
+      throw error as! E
+    }
+  }
+
+  // ABI-only entrypoint
+  @usableFromInline
+  @_disfavoredOverload
+  func map<T>(
     _ transform: (Element) throws -> T
   ) rethrows -> [T] {
-    return try _box._map(transform)
+    do {
+      return try map(transform)
+    } catch {
+      try _rethrowsViaClosure { throw error }
+      Builtin.unreachable()
+    }
   }
 
   @inlinable
@@ -1488,10 +1546,29 @@ extension AnyBidirectionalCollection {
   }
 
   @inlinable
-  public func map<T>(
+  @_alwaysEmitIntoClient
+  public func map<T, E>(
+    _ transform: (Element) throws(E) -> T
+  ) throws(E) -> [T] {
+    do {
+      return try _box._map(transform)
+    } catch {
+      throw error as! E
+    }
+  }
+
+  // ABI-only entrypoint
+  @usableFromInline
+  @_disfavoredOverload
+  func map<T>(
     _ transform: (Element) throws -> T
   ) rethrows -> [T] {
-    return try _box._map(transform)
+    do {
+      return try map(transform)
+    } catch {
+      try _rethrowsViaClosure { throw error }
+      Builtin.unreachable()
+    }
   }
 
   @inlinable
@@ -1583,10 +1660,29 @@ extension AnyRandomAccessCollection {
   }
 
   @inlinable
-  public func map<T>(
+  @_alwaysEmitIntoClient
+  public func map<T, E>(
+    _ transform: (Element) throws(E) -> T
+  ) throws(E) -> [T] {
+    do {
+      return try _box._map(transform)
+    } catch {
+      throw error as! E
+    }
+  }
+
+  // ABI-only entrypoint
+  @usableFromInline
+  @_disfavoredOverload
+  func map<T>(
     _ transform: (Element) throws -> T
   ) rethrows -> [T] {
-    return try _box._map(transform)
+    do {
+      return try map(transform)
+    } catch {
+      try _rethrowsViaClosure { throw error }
+      Builtin.unreachable()
+    }
   }
 
   @inlinable

stdlib/public/core/Misc.swift

@@ -159,6 +159,17 @@ public func _unsafePerformance<T>(_ c: () -> T) -> T {
   return c()
 }
 
+// Helper function that exploits a bug in rethrows checking to
+// allow us to call rethrows functions from generic typed-throws functions
+// and vice-versa.
+@usableFromInline
+@_alwaysEmitIntoClient
+@inline(__always)
+func _rethrowsViaClosure(_ fn: () throws -> ()) rethrows {
+  try fn()
+}
+
+
 /// This marker protocol represents types that support copying.
 @_marker public protocol Copyable {}
 

stdlib/public/core/Sequence.swift

@@ -670,9 +670,10 @@ extension Sequence {
   ///
   /// - Complexity: O(*n*), where *n* is the length of the sequence.
   @inlinable
-  public func map<T>(
-    _ transform: (Element) throws -> T
-  ) rethrows -> [T] {
+  @_alwaysEmitIntoClient
+  public func map<T, E>(
+    _ transform: (Element) throws(E) -> T
+  ) throws(E) -> [T] {
     let initialCapacity = underestimatedCount
     var result = ContiguousArray<T>()
     result.reserveCapacity(initialCapacity)
@@ -690,6 +691,20 @@ extension Sequence {
     return Array(result)
   }
 
+  // ABI-only entrypoint
+  @usableFromInline
+  @_disfavoredOverload
+  func map<T>(
+    _ transform: (Element) throws -> T
+  ) rethrows -> [T] {
+    do {
+      return try map(transform)
+    } catch {
+      try _rethrowsViaClosure { throw error }
+      Builtin.unreachable()
+    }
+  }
+
   /// Returns an array containing, in order, the elements of the sequence
   /// that satisfy the given predicate.
   ///