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

Azoy · Azoy · commit 97d9339d7615 · 2025-05-13T10:40:29.000-07:00
diff --git a/stdlib/public/core/Dictionary.swift b/stdlib/public/core/Dictionary.swift
@@ -926,10 +926,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))
   }
 
@@ -959,12 +959,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
@@ -559,10 +559,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
@@ -452,10 +452,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
@@ -755,10 +755,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 = unsafe _DictionaryStorage<Key, T>.copy(original: _storage)
     unsafe _internalInvariant(resultStorage._seed == _storage._seed)
     let result = unsafe _NativeDictionary<Key, T>(resultStorage)
diff --git a/stdlib/public/core/Sequence.swift b/stdlib/public/core/Sequence.swift
@@ -705,18 +705,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.
   ///
@@ -734,20 +722,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() {
@@ -809,11 +795,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
@@ -664,12 +664,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)
@@ -721,12 +720,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
@@ -375,3 +375,29 @@ Accessor UnsafeMutableBufferPointer.indices.Get() has generic signature change f
 
 Func type(of:) has generic signature change from <T, Metatype> to <T, Metatype where T : ~Copyable, T : ~Escapable>
 Func type(of:) has parameter 0 changing from Default to Shared
+
+// 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
