Adopt typed throws in some Dictionary APIs as well as Sequence APIs

Azoy · Azoy · commit fccc2021152d · 2024-12-04T11:46:14.000-08:00
diff --git a/stdlib/public/core/Dictionary.swift b/stdlib/public/core/Dictionary.swift
@@ -916,10 +916,10 @@ extension Dictionary {
   ///   this dictionary.
   ///
   /// - Complexity: O(*n*), where *n* is the length of the dictionary.
-  @inlinable
-  public func mapValues<T>(
-    _ transform: (Value) throws -> T
-  ) rethrows -> Dictionary<Key, T> {
+  @_alwaysEmitIntoClient
+  public func mapValues<T, E: Error>(
+    _ transform: (Value) throws(E) -> T
+  ) throws(E) -> Dictionary<Key, T> {
     return try Dictionary<Key, T>(_native: _variant.mapValues(transform))
   }
 
@@ -949,12 +949,13 @@ extension Dictionary {
   ///
   /// - Complexity: O(*m* + *n*), where *n* is the length of the original
   ///   dictionary and *m* is the length of the resulting dictionary.
-  @inlinable
-  public func compactMapValues<T>(
-    _ transform: (Value) throws -> T?
-  ) rethrows -> Dictionary<Key, T> {
-    let result: _NativeDictionary<Key, T> =
-      try self.reduce(into: _NativeDictionary<Key, T>()) { (result, element) in
+  @_alwaysEmitIntoClient
+  public func compactMapValues<T, E: Error>(
+    _ transform: (Value) throws(E) -> T?
+  ) throws(E) -> Dictionary<Key, T> {
+    let result: _NativeDictionary<Key, T> = try self.reduce(
+      into: _NativeDictionary<Key, T>()
+    ) { (result, element) throws(E) in
       if let value = try transform(element.value) {
         result.insertNew(key: element.key, value: value)
       }
diff --git a/stdlib/public/core/DictionaryBridging.swift b/stdlib/public/core/DictionaryBridging.swift
@@ -557,10 +557,10 @@ extension __CocoaDictionary: _DictionaryBuffer {
 }
 
 extension __CocoaDictionary {
-  @inlinable
-  internal func mapValues<Key: Hashable, Value, T>(
-    _ transform: (Value) throws -> T
-  ) rethrows -> _NativeDictionary<Key, T> {
+  @_alwaysEmitIntoClient
+  internal func mapValues<Key: Hashable, Value, T, E: Error>(
+    _ transform: (Value) throws(E) -> T
+  ) throws(E) -> _NativeDictionary<Key, T> {
     var result = _NativeDictionary<Key, T>(capacity: self.count)
     for (cocoaKey, cocoaValue) in self {
       let key = _forceBridgeFromObjectiveC(cocoaKey, Key.self)
diff --git a/stdlib/public/core/DictionaryVariant.swift b/stdlib/public/core/DictionaryVariant.swift
@@ -451,10 +451,10 @@ extension Dictionary._Variant {
 }
 
 extension Dictionary._Variant {
-  @inlinable
-  internal func mapValues<T>(
-    _ transform: (Value) throws -> T
-  ) rethrows -> _NativeDictionary<Key, T> {
+  @_alwaysEmitIntoClient
+  internal func mapValues<T, E: Error>(
+    _ transform: (Value) throws(E) -> T
+  ) throws(E) -> _NativeDictionary<Key, T> {
 #if _runtime(_ObjC)
     guard isNative else {
       return try asCocoa.mapValues(transform)
diff --git a/stdlib/public/core/LegacyABI.swift b/stdlib/public/core/LegacyABI.swift
@@ -113,3 +113,159 @@ internal func _unsafeMinus(_ lhs: Int, _ rhs: Int) -> Int {
   return lhs &- rhs
 #endif
 }
+
+extension Dictionary {
+  @usableFromInline
+  @_silgen_name("$sSD9mapValuesySDyxqd__Gqd__q_KXEKlF")
+  internal func __abi_mapValues<T>(
+    _ transform: (Value) throws -> T
+  ) rethrows -> Dictionary<Key, T> {
+    return try Dictionary<Key, T>(_native: _variant.mapValues(transform))
+  }
+
+  @usableFromInline
+  @_silgen_name("$sSD16compactMapValuesySDyxqd__Gqd__Sgq_KXEKlF")
+  internal func __abi_compactMapValues<T>(
+    _ transform: (Value) throws -> T?
+  ) rethrows -> Dictionary<Key, T> {
+    let result: _NativeDictionary<Key, T> =
+      try self.reduce(into: _NativeDictionary<Key, T>()) { (result, element) in
+      if let value = try transform(element.value) {
+        result.insertNew(key: element.key, value: value)
+      }
+    }
+    return Dictionary<Key, T>(_native: result)
+  }
+}
+
+extension Dictionary._Variant {
+  @usableFromInline
+  @_silgen_name("$sSD8_VariantV9mapValuesys17_NativeDictionaryVyxqd__Gqd__q_KXEKlF")
+  internal func __abi_mapValues<T>(
+    _ transform: (Value) throws -> T
+  ) rethrows -> _NativeDictionary<Key, T> {
+#if _runtime(_ObjC)
+    guard isNative else {
+      return try asCocoa.mapValues(transform)
+    }
+#endif
+    return try asNative.mapValues(transform)
+  }
+}
+
+extension __CocoaDictionary {
+  @usableFromInline
+  @_silgen_name("$ss17__CocoaDictionaryV9mapValuesys07_NativeB0Vyxq0_Gq0_q_KXEKSHRzr1_lF")
+  internal func __abi_mapValues<Key: Hashable, Value, T>(
+    _ transform: (Value) throws -> T
+  ) rethrows -> _NativeDictionary<Key, T> {
+    var result = _NativeDictionary<Key, T>(capacity: self.count)
+    for (cocoaKey, cocoaValue) in self {
+      let key = _forceBridgeFromObjectiveC(cocoaKey, Key.self)
+      let value = _forceBridgeFromObjectiveC(cocoaValue, Value.self)
+      try result.insertNew(key: key, value: transform(value))
+    }
+    return result
+  }
+}
+
+extension _NativeDictionary {
+  @usableFromInline
+  @_silgen_name("$ss17_NativeDictionaryV9mapValuesyAByxqd__Gqd__q_KXEKlF")
+  internal func __abi_mapValues<T>(
+    _ transform: (Value) throws -> T
+  ) rethrows -> _NativeDictionary<Key, T> {
+    let resultStorage = _DictionaryStorage<Key, T>.copy(original: _storage)
+    _internalInvariant(resultStorage._seed == _storage._seed)
+    let result = _NativeDictionary<Key, T>(resultStorage)
+    // Because the current and new buffer have the same scale and seed, we can
+    // initialize to the same locations in the new buffer, skipping hash value
+    // recalculations.
+    for bucket in hashTable {
+      let key = self.uncheckedKey(at: bucket)
+      let value = self.uncheckedValue(at: bucket)
+      try result._insert(at: bucket, key: key, value: transform(value))
+    }
+    return result
+  }
+}
+
+extension Sequence {
+  // ABI-only entrypoint for the rethrows version of map, which has been
+  // superseded by the typed-throws version. Expressed as "throws", which is
+  // ABI-compatible with "rethrows".
+  @_spi(SwiftStdlibLegacyABI) @available(swift, obsoleted: 1)
+  @usableFromInline
+  @_silgen_name("$sSTsE3mapySayqd__Gqd__7ElementQzKXEKlF")
+  func __rethrows_map<T>(
+    _ transform: (Element) throws -> T
+  ) throws -> [T] {
+    try map(transform)
+  }
+
+  @usableFromInline
+  @_silgen_name("$sSTsE6filterySay7ElementQzGSbACKXEKF")
+  internal __consuming func __abi_filter(
+    _ isIncluded: (Element) throws -> Bool
+  ) rethrows -> [Element] {
+    return try __abi__filter(isIncluded)
+  }
+
+  @usableFromInline
+  @_silgen_name("$sSTsE7_filterySay7ElementQzGSbACKXEKF")
+  internal func __abi__filter(
+    _ isIncluded: (Element) throws -> Bool
+  ) rethrows -> [Element] {
+
+    var result = ContiguousArray<Element>()
+
+    var iterator = self.makeIterator()
+
+    while let element = iterator.next() {
+      if try isIncluded(element) {
+        result.append(element)
+      }
+    }
+
+    return Array(result)
+  }
+
+  @usableFromInline
+  @_semantics("sequence.forEach")
+  @_silgen_name("$sSTsE7forEachyyy7ElementQzKXEKF")
+  internal func __abi_forEach(
+    _ body: (Element) throws -> Void
+  ) rethrows {
+    for element in self {
+      try body(element)
+    }
+  }
+
+  @usableFromInline
+  @_silgen_name("$sSTsE6reduceyqd__qd___qd__qd___7ElementQztKXEtKlF")
+  internal func __abi_reduce<Result>(
+    _ initialResult: Result,
+    _ nextPartialResult:
+      (_ partialResult: Result, Element) throws -> Result
+  ) rethrows -> Result {
+    var accumulator = initialResult
+    for element in self {
+      accumulator = try nextPartialResult(accumulator, element)
+    }
+    return accumulator
+  }
+
+  @usableFromInline
+  @_silgen_name("$sSTsE6reduce4into_qd__qd__n_yqd__z_7ElementQztKXEtKlF")
+  internal func __abi_reduce<Result>(
+    into initialResult: __owned Result,
+    _ updateAccumulatingResult:
+      (_ partialResult: inout Result, Element) throws -> ()
+  ) rethrows -> Result {
+    var accumulator = initialResult
+    for element in self {
+      try updateAccumulatingResult(&accumulator, element)
+    }
+    return accumulator
+  }
+}
diff --git a/stdlib/public/core/NativeDictionary.swift b/stdlib/public/core/NativeDictionary.swift
@@ -746,10 +746,10 @@ extension _NativeDictionary { // Deletion
 }
 
 extension _NativeDictionary { // High-level operations
-  @inlinable
-  internal func mapValues<T>(
-    _ transform: (Value) throws -> T
-  ) rethrows -> _NativeDictionary<Key, T> {
+  @_alwaysEmitIntoClient
+  internal func mapValues<T, E: Error>(
+    _ transform: (Value) throws(E) -> T
+  ) throws(E) -> _NativeDictionary<Key, T> {
     let resultStorage = _DictionaryStorage<Key, T>.copy(original: _storage)
     _internalInvariant(resultStorage._seed == _storage._seed)
     let result = _NativeDictionary<Key, T>(resultStorage)
diff --git a/stdlib/public/core/Sequence.swift b/stdlib/public/core/Sequence.swift
@@ -703,18 +703,6 @@ extension Sequence {
     return Array(result)
   }
 
-  // ABI-only entrypoint for the rethrows version of map, which has been
-  // superseded by the typed-throws version. Expressed as "throws", which is
-  // ABI-compatible with "rethrows".
-  @_spi(SwiftStdlibLegacyABI) @available(swift, obsoleted: 1)
-  @usableFromInline
-  @_silgen_name("$sSTsE3mapySayqd__Gqd__7ElementQzKXEKlF")
-  func __rethrows_map<T>(
-    _ transform: (Element) throws -> T
-  ) throws -> [T] {
-    try map(transform)
-  }
-
   /// Returns an array containing, in order, the elements of the sequence
   /// that satisfy the given predicate.
   ///
@@ -732,20 +720,18 @@ extension Sequence {
   /// - Returns: An array of the elements that `isIncluded` allowed.
   ///
   /// - Complexity: O(*n*), where *n* is the length of the sequence.
-  @inlinable
-  public __consuming func filter(
-    _ isIncluded: (Element) throws -> Bool
-  ) rethrows -> [Element] {
-    return try _filter(isIncluded)
+  @_alwaysEmitIntoClient
+  public __consuming func filter<E: Error>(
+    _ isIncluded: (Element) throws(E) -> Bool
+  ) throws(E) -> [Element] {
+    try _filter(isIncluded)
   }
 
-  @_transparent
-  public func _filter(
-    _ isIncluded: (Element) throws -> Bool
-  ) rethrows -> [Element] {
-
+  @_alwaysEmitIntoClient
+  public func _filter<E: Error>(
+    _ isIncluded: (Element) throws(E) -> Bool
+  ) throws(E) -> [Element] {
     var result = ContiguousArray<Element>()
-
     var iterator = self.makeIterator()
 
     while let element = iterator.next() {
@@ -807,11 +793,11 @@ extension Sequence {
   ///
   /// - Parameter body: A closure that takes an element of the sequence as a
   ///   parameter.
+  @_alwaysEmitIntoClient
   @_semantics("sequence.forEach")
-  @inlinable
-  public func forEach(
-    _ body: (Element) throws -> Void
-  ) rethrows {
+  public func forEach<E: Error>(
+    _ body: (Element) throws(E) -> Void
+  ) throws(E) {
     for element in self {
       try body(element)
     }
diff --git a/stdlib/public/core/SequenceAlgorithms.swift b/stdlib/public/core/SequenceAlgorithms.swift
@@ -662,12 +662,11 @@ extension Sequence {
   ///   the result is `initialResult`.
   ///
   /// - Complexity: O(*n*), where *n* is the length of the sequence.
-  @inlinable
-  public func reduce<Result>(
-    _ initialResult: Result,
-    _ nextPartialResult:
-      (_ partialResult: Result, Element) throws -> Result
-  ) rethrows -> Result {
+  @_alwaysEmitIntoClient
+  public func reduce<Result: ~Copyable, E: Error>(
+    _ initialResult: consuming Result,
+    _ nextPartialResult: (borrowing Result, Element) throws(E) -> Result
+  ) throws(E) -> Result {
     var accumulator = initialResult
     for element in self {
       accumulator = try nextPartialResult(accumulator, element)
@@ -719,12 +718,11 @@ extension Sequence {
   ///   the result is `initialResult`.
   ///
   /// - Complexity: O(*n*), where *n* is the length of the sequence.
-  @inlinable
-  public func reduce<Result>(
-    into initialResult: __owned Result,
-    _ updateAccumulatingResult:
-      (_ partialResult: inout Result, Element) throws -> ()
-  ) rethrows -> Result {
+  @_alwaysEmitIntoClient
+  public func reduce<Result: ~Copyable, E: Error>(
+    into initialResult: consuming Result,
+    _ updateAccumulatingResult: (inout Result, Element) throws(E) -> ()
+  ) throws(E) -> Result {
     var accumulator = initialResult
     for element in self {
       try updateAccumulatingResult(&accumulator, element)
diff --git a/test/api-digester/Outputs/stability-stdlib-source-base.swift.expected b/test/api-digester/Outputs/stability-stdlib-source-base.swift.expected
@@ -378,3 +378,30 @@ Struct UnsafePointer is now with @unsafe
 Struct UnsafeRawBufferPointer is now with @unsafe
 Struct UnsafeRawPointer is now with @unsafe
 Var Optional.unsafelyUnwrapped is now with @unsafe
+
+// Adoption of typed throws for Dictionary.compactMapValues(_:)
+Func Dictionary.compactMapValues(_:) has generic signature change from <Key, Value, T where Key : Swift.Hashable> to <Key, Value, T, E where Key : Swift.Hashable, E : Swift.Error>
+Func Dictionary.compactMapValues(_:) is now without @rethrows
+
+// Adoption of typed throws for Dictionary.mapValues(_:)
+Func Dictionary.mapValues(_:) has generic signature change from <Key, Value, T where Key : Swift.Hashable> to <Key, Value, T, E where Key : Swift.Hashable, E : Swift.Error>
+Func Dictionary.mapValues(_:) is now without @rethrows
+
+// Adoption of typed throws for Sequence.filter(_:)
+Func Sequence.filter(_:) has generic signature change from <Self where Self : Swift.Sequence> to <Self, E where Self : Swift.Sequence, E : Swift.Error>
+Func Sequence.filter(_:) is now without @rethrows
+
+// Adoption of typed throws for Sequence.forEach(_:)
+Func Sequence.forEach(_:) has generic signature change from <Self where Self : Swift.Sequence> to <Self, E where Self : Swift.Sequence, E : Swift.Error>
+Func Sequence.forEach(_:) is now without @rethrows
+
+// Adoption of typed throws for Sequence.reduce(_:_:)
+Func Sequence.reduce(_:_:) has generic signature change from <Self, Result where Self : Swift.Sequence> to <Self, Result, E where Self : Swift.Sequence, E : Swift.Error, Result : ~Copyable>
+Func Sequence.reduce(_:_:) has parameter 0 changing from Default to Owned
+Func Sequence.reduce(_:_:) is now without @rethrows
+
+// Adoption of typed throws for Sequence.reduce(into:_:)
+Func Sequence.reduce(into:_:) has generic signature change from <Self, Result where Self : Swift.Sequence> to <Self, Result, E where Self : Swift.Sequence, E : Swift.Error, Result : ~Copyable>
+Func Sequence.reduce(into:_:) has parameter 1 type change from (inout Result, Self.Element) throws -> () to (inout Result, Self.Element) throws(E) -> ()
+Func Sequence.reduce(into:_:) is now without @rethrows
+
diff --git a/test/api-digester/stability-stdlib-abi-without-asserts.test b/test/api-digester/stability-stdlib-abi-without-asserts.test
