stdlib: add convenience APIs for Set<AnyHashable> and Dictionary<AnyHashable, *>

Implements SE-0131 "Add AnyHashable to the standard library".

stdlib/public/core/GroupInfo.json

@@ -78,7 +78,9 @@
         "SliceBuffer.swift",
         "SwiftNativeNSArray.swift"],
       "HashedCollections": [
-        "HashedCollections.swift"]
+        "HashedCollections.swift",
+        "HashedCollectionsAnyHashableExtensions.swift"
+      ]
     }
   ],
   "C": [

stdlib/public/core/Hashable.swift

@@ -10,6 +10,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// FIXME(ABI)(compiler limitation): This protocol exists to identify
+// hashable types.  It is used for defining an imitation of a generic
+// subscript on `Dictionary<AnyHashable, *>`.
+public protocol _Hashable {
+  func _toAnyHashable() -> AnyHashable
+}
+
 /// A type that provides an integer hash value.
 ///
 /// You can use any type that conforms to the `Hashable` protocol in a set or
@@ -83,7 +90,7 @@
 ///         print("New tap detected at (\(nextTap.x), \(nextTap.y)).")
 ///     }
 ///     // Prints "New tap detected at (0, 1).")
-public protocol Hashable : Equatable {
+public protocol Hashable : _Hashable, Equatable {
   /// The hash value.
   ///
   /// Hash values are not guaranteed to be equal across different executions of

stdlib/public/core/HashedCollectionsAnyHashableExtensions.swift.gyb

@@ -0,0 +1,172 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// FIXME(ABI)(compiler limitation): This protocol exists to identify
+// `AnyHashable` in conditional extensions.  Replace this protocol
+// with conditional extensions on `Set` and `Dictionary` "where Key ==
+// AnyHashable".
+public protocol _AnyHashableProtocol {
+  var base: Any { get }
+}
+
+extension AnyHashable : _AnyHashableProtocol {}
+
+//===----------------------------------------------------------------------===//
+// Convenience APIs for Set<AnyHashable>
+//===----------------------------------------------------------------------===//
+
+// FIXME: remove these trampolines when extensions below can be
+// properly expressed in the language.
+extension Set {
+  @inline(__always)
+  internal func _concreteElement_contains(_ member: Element) -> Bool {
+    return contains(member)
+  }
+
+  @inline(__always)
+  internal func _concreteElement_index(of member: Element) -> Index? {
+    return index(of: member)
+  }
+
+  @inline(__always)
+  internal mutating func _concreteElement_insert(
+    _ newMember: Element
+  ) -> (inserted: Bool, memberAfterInsert: Element) {
+    return insert(newMember)
+  }
+
+  @inline(__always)
+  internal mutating func _concreteElement_update(
+    with newMember: Element
+  ) -> Element? {
+    return update(with: newMember)
+  }
+
+  @inline(__always)
+  internal mutating func _concreteElement_remove(
+    _ member: Element
+  ) -> Element? {
+    return remove(member)
+  }
+}
+
+// FIXME(ABI)(compiler limitation): replace with `where Element == AnyHashable`.
+extension Set where Element : _AnyHashableProtocol {
+  public func contains<ConcreteElement : Hashable>(
+    _ member: ConcreteElement
+  ) -> Bool {
+    return _concreteElement_contains(AnyHashable(member) as! Element)
+  }
+
+  public func index<ConcreteElement : Hashable>(
+    of member: ConcreteElement
+  ) -> SetIndex<Element>? {
+    return _concreteElement_index(of: AnyHashable(member) as! Element)
+  }
+
+  public mutating func insert<ConcreteElement : Hashable>(
+    _ newMember: ConcreteElement
+  ) -> (inserted: Bool, memberAfterInsert: ConcreteElement) {
+    let (inserted, memberAfterInsert) =
+      _concreteElement_insert(AnyHashable(newMember) as! Element)
+    return (
+      inserted: inserted,
+      memberAfterInsert: memberAfterInsert.base as! ConcreteElement)
+  }
+
+  @discardableResult
+  public mutating func update<ConcreteElement : Hashable>(
+    with newMember: ConcreteElement
+  ) -> ConcreteElement? {
+    return _concreteElement_update(with: AnyHashable(newMember) as! Element)
+      .map { $0.base as! ConcreteElement }
+  }
+
+  @discardableResult
+  public mutating func remove<ConcreteElement : Hashable>(
+    _ member: ConcreteElement
+  ) -> ConcreteElement? {
+    return _concreteElement_remove(AnyHashable(member) as! Element)
+      .map { $0.base as! ConcreteElement }
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// Convenience APIs for Dictionary<AnyHashable, *>
+//===----------------------------------------------------------------------===//
+
+// FIXME: remove these trampolines when extensions below can be
+// properly expressed in the language.
+extension Dictionary {
+  @inline(__always)
+  internal func _concreteKey_index(forKey key: Key) -> Index? {
+    return index(forKey: key)
+  }
+
+  internal subscript(_concreteKey key: Key) -> Value? {
+    @inline(__always)
+    get {
+      return self[key]
+    }
+    @inline(__always)
+    set(newValue) {
+      self[key] = newValue
+    }
+  }
+
+  @inline(__always)
+  internal mutating func _concreteKey_updateValue(
+    _ value: Value, forKey key: Key
+  ) -> Value? {
+    return updateValue(value, forKey: key)
+  }
+
+  @inline(__always)
+  internal mutating func _concreteKey_removeValue(forKey key: Key) -> Value? {
+    return removeValue(forKey: key)
+  }
+}
+
+// FIXME(ABI)(compiler limitation): replace with `where Element == AnyHashable`.
+extension Dictionary where Key : _AnyHashableProtocol {
+  public func index<ConcreteKey : Hashable>(forKey key: ConcreteKey)
+    -> DictionaryIndex<Key, Value>?
+  {
+    return _concreteKey_index(forKey: AnyHashable(key) as! Key)
+  }
+
+  public subscript(_ key: _Hashable) -> Value? {
+    // FIXME(ABI)(compiler limitation): replace this API with a
+    // generic subscript.
+    get {
+      return self[_concreteKey: key._toAnyHashable() as! Key]
+    }
+    set {
+      self[_concreteKey: key._toAnyHashable() as! Key] = newValue
+    }
+  }
+
+  @discardableResult
+  public mutating func updateValue<ConcreteKey : Hashable>(
+    _ value: Value, forKey key: ConcreteKey
+  ) -> Value? {
+    return _concreteKey_updateValue(value, forKey: AnyHashable(key) as! Key)
+  }
+
+  @discardableResult
+  public mutating func removeValue<ConcreteKey : Hashable>(
+    forKey key: ConcreteKey
+  ) -> Value? {
+    return _concreteKey_removeValue(forKey: AnyHashable(key) as! Key)
+  }
+}
+

validation-test/stdlib/DictionaryAnyHashableExtensions.swift

@@ -0,0 +1,157 @@
+// RUN: %target-run-simple-swift
+// REQUIRES: executable_test
+
+import StdlibUnittest
+
+var DictionaryTests = TestSuite("Dictionary")
+
+DictionaryTests.test("index<Hashable>(forKey:)") {
+  let d: [AnyHashable : Int] = [
+    AnyHashable(10) : 1010,
+    AnyHashable(20) : 2020,
+    AnyHashable(30.0) : 3030,
+  ]
+
+  expectEqual(1010, d[d.index(forKey: 10)!].value)
+  expectEqual(2020, d[d.index(forKey: 20)!].value)
+  expectEqual(3030, d[d.index(forKey: 30.0)!].value)
+
+  expectEmpty(d.index(forKey: 10.0))
+  expectEmpty(d.index(forKey: 20.0))
+  expectEmpty(d.index(forKey: 30))
+}
+
+DictionaryTests.test("subscript<Hashable>(_:)") {
+  var d: [AnyHashable : Int] = [
+    AnyHashable(10) : 1010,
+    AnyHashable(20) : 2020,
+    AnyHashable(30.0) : 3030,
+  ]
+
+  expectEqual(1010, d[10])
+  expectEqual(2020, d[20])
+  expectEqual(3030, d[30.0])
+
+  d[10] = 101010
+  do {
+    let expected: [AnyHashable : Int] = [
+      AnyHashable(10) : 101010,
+      AnyHashable(20) : 2020,
+      AnyHashable(30.0) : 3030,
+    ]
+    expectEqual(expected, d)
+  }
+
+  d[20] = 202020
+  do {
+    let expected: [AnyHashable : Int] = [
+      AnyHashable(10) : 101010,
+      AnyHashable(20) : 202020,
+      AnyHashable(30.0) : 3030,
+    ]
+    expectEqual(expected, d)
+  }
+
+  d[30.0] = 303030
+  do {
+    let expected: [AnyHashable : Int] = [
+      AnyHashable(10) : 101010,
+      AnyHashable(20) : 202020,
+      AnyHashable(30.0) : 303030,
+    ]
+    expectEqual(expected, d)
+  }
+}
+
+DictionaryTests.test("updateValue<Hashable>(_:forKey:)") {
+  var d: [AnyHashable : Int] = [
+    AnyHashable(10) : 1010,
+    AnyHashable(20) : 2020,
+    AnyHashable(30.0) : 3030,
+  ]
+
+  expectEqual(1010, d.updateValue(101010, forKey: 10)!)
+  do {
+    let expected: [AnyHashable : Int] = [
+      AnyHashable(10) : 101010,
+      AnyHashable(20) : 2020,
+      AnyHashable(30.0) : 3030,
+    ]
+    expectEqual(expected, d)
+  }
+
+  expectEqual(2020, d.updateValue(202020, forKey: 20)!)
+  do {
+    let expected: [AnyHashable : Int] = [
+      AnyHashable(10) : 101010,
+      AnyHashable(20) : 202020,
+      AnyHashable(30.0) : 3030,
+    ]
+    expectEqual(expected, d)
+  }
+
+  expectEqual(3030, d.updateValue(303030, forKey: 30.0)!)
+  do {
+    let expected: [AnyHashable : Int] = [
+      AnyHashable(10) : 101010,
+      AnyHashable(20) : 202020,
+      AnyHashable(30.0) : 303030,
+    ]
+    expectEqual(expected, d)
+  }
+
+  expectEmpty(d.updateValue(4040, forKey: 10.0))
+  do {
+    let expected: [AnyHashable : Int] = [
+      AnyHashable(10) : 101010,
+      AnyHashable(20) : 202020,
+      AnyHashable(30.0) : 303030,
+      AnyHashable(10.0) : 4040,
+    ]
+    expectEqual(expected, d)
+  }
+
+  expectEmpty(d.updateValue(5050, forKey: 20.0))
+  do {
+    let expected: [AnyHashable : Int] = [
+      AnyHashable(10) : 101010,
+      AnyHashable(20) : 202020,
+      AnyHashable(30.0) : 303030,
+      AnyHashable(10.0) : 4040,
+      AnyHashable(20.0) : 5050,
+    ]
+    expectEqual(expected, d)
+  }
+
+  expectEmpty(d.updateValue(6060, forKey: 30))
+  do {
+    let expected: [AnyHashable : Int] = [
+      AnyHashable(10) : 101010,
+      AnyHashable(20) : 202020,
+      AnyHashable(30.0) : 303030,
+      AnyHashable(10.0) : 4040,
+      AnyHashable(20.0) : 5050,
+      AnyHashable(30) : 6060,
+    ]
+    expectEqual(expected, d)
+  }
+}
+
+DictionaryTests.test("removeValue<Hashable>(forKey:)") {
+  var d: [AnyHashable : Int] = [
+    AnyHashable(10) : 1010,
+    AnyHashable(20) : 2020,
+    AnyHashable(30.0) : 3030,
+  ]
+
+  expectEmpty(d.removeValue(forKey: 10.0))
+  expectEmpty(d.removeValue(forKey: 20.0))
+  expectEmpty(d.removeValue(forKey: 30))
+
+  expectEqual(1010, d.removeValue(forKey: 10)!)
+  expectEqual(2020, d.removeValue(forKey: 20)!)
+  expectEqual(3030, d.removeValue(forKey: 30.0)!)
+}
+
+runAllTests()
+

validation-test/stdlib/SetAnyHashableExtensions.swift

@@ -0,0 +1,234 @@
+// RUN: %target-run-simple-swift
+// REQUIRES: executable_test
+
+import StdlibUnittest
+
+class TestHashableBase : Hashable {
+  var value: Int
+  var identity: Int
+  init(_ value: Int, identity: Int) {
+    self.value = value
+    self.identity = identity
+  }
+  var hashValue: Int {
+    return value
+  }
+  static func == (
+    lhs: TestHashableBase,
+    rhs: TestHashableBase
+  ) -> Bool {
+    return lhs.value == rhs.value
+  }
+}
+
+class TestHashableDerivedA : TestHashableBase {}
+class TestHashableDerivedB : TestHashableBase {}
+
+var SetTests = TestSuite("Set")
+
+SetTests.test("contains<Hashable>(_:)") {
+  let s: Set<AnyHashable> = [
+    AnyHashable(1010), AnyHashable(2020), AnyHashable(3030.0)
+  ]
+  expectTrue(s.contains(1010))
+  expectTrue(s.contains(2020))
+  expectTrue(s.contains(3030.0))
+
+  expectFalse(s.contains(1010.0))
+  expectFalse(s.contains(2020.0))
+  expectFalse(s.contains(3030))
+}
+
+SetTests.test("index<Hashable>(of:)") {
+  let s: Set<AnyHashable> = [
+    AnyHashable(1010), AnyHashable(2020), AnyHashable(3030.0)
+  ]
+  expectEqual(AnyHashable(1010), s[s.index(of: 1010)!])
+  expectEqual(AnyHashable(2020), s[s.index(of: 2020)!])
+  expectEqual(AnyHashable(3030.0), s[s.index(of: 3030.0)!])
+
+  expectEmpty(s.index(of: 1010.0))
+  expectEmpty(s.index(of: 2020.0))
+  expectEmpty(s.index(of: 3030))
+}
+
+SetTests.test("insert<Hashable>(_:)") {
+  var s: Set<AnyHashable> = [
+    AnyHashable(MinimalHashableValue(1010, identity: 1)),
+    AnyHashable(MinimalHashableValue(2020, identity: 1)),
+    AnyHashable(MinimalHashableClass(3030, identity: 1)),
+  ]
+
+  do {
+    let (inserted, memberAfterInsert) =
+      s.insert(MinimalHashableValue(1010, identity: 2))
+    expectFalse(inserted)
+    expectEqual(1, memberAfterInsert.identity)
+  }
+  do {
+    let (inserted, memberAfterInsert) =
+      s.insert(MinimalHashableValue(2020, identity: 2))
+    expectFalse(inserted)
+    expectEqual(1, memberAfterInsert.identity)
+  }
+  do {
+    let (inserted, memberAfterInsert) =
+      s.insert(MinimalHashableClass(3030, identity: 2))
+    expectFalse(inserted)
+    expectEqual(1, memberAfterInsert.identity)
+  }
+
+  do {
+    let (inserted, memberAfterInsert) =
+      s.insert(MinimalHashableClass(1010, identity: 2))
+    expectTrue(inserted)
+    expectEqual(2, memberAfterInsert.identity)
+  }
+  do {
+    let (inserted, memberAfterInsert) =
+      s.insert(MinimalHashableClass(2020, identity: 2))
+    expectTrue(inserted)
+    expectEqual(2, memberAfterInsert.identity)
+  }
+  do {
+    let (inserted, memberAfterInsert) =
+      s.insert(MinimalHashableValue(3030, identity: 2))
+    expectTrue(inserted)
+    expectEqual(2, memberAfterInsert.identity)
+  }
+
+  let expected: Set<AnyHashable> = [
+    AnyHashable(MinimalHashableValue(1010, identity: 1)),
+    AnyHashable(MinimalHashableValue(2020, identity: 1)),
+    AnyHashable(MinimalHashableClass(3030, identity: 1)),
+
+    AnyHashable(MinimalHashableClass(1010, identity: 2)),
+    AnyHashable(MinimalHashableClass(2020, identity: 2)),
+    AnyHashable(MinimalHashableValue(3030, identity: 2)),
+  ]
+  expectEqual(expected, s)
+}
+
+SetTests.test("insert<Hashable>(_:)/CastTrap")
+  .crashOutputMatches("Could not cast value of type 'main.TestHashableDerivedA'")
+  .crashOutputMatches("to 'main.TestHashableDerivedB'")
+  .code {
+  var s: Set<AnyHashable> = [
+    AnyHashable(TestHashableDerivedA(1010, identity: 1)),
+  ]
+
+  do {
+    let (inserted, memberAfterInsert) =
+      s.insert(TestHashableDerivedA(1010, identity: 2))
+    expectFalse(inserted)
+    expectEqual(1, memberAfterInsert.identity)
+  }
+
+  expectCrashLater()
+  _ = s.insert(TestHashableDerivedB(1010, identity: 3))
+}
+
+SetTests.test("update<Hashable>(with:)") {
+  var s: Set<AnyHashable> = [
+    AnyHashable(MinimalHashableValue(1010, identity: 1)),
+    AnyHashable(MinimalHashableValue(2020, identity: 1)),
+    AnyHashable(MinimalHashableClass(3030, identity: 1)),
+  ]
+
+  do {
+    let old = s.update(with: MinimalHashableValue(1010, identity: 2))!
+    expectEqual(1, old.identity)
+  }
+  do {
+    let old = s.update(with: MinimalHashableValue(2020, identity: 2))!
+    expectEqual(1, old.identity)
+  }
+  do {
+    let old = s.update(with: MinimalHashableClass(3030, identity: 2))!
+    expectEqual(1, old.identity)
+  }
+
+  expectEmpty(s.update(with: MinimalHashableClass(1010, identity: 2)))
+  expectEmpty(s.update(with: MinimalHashableClass(2020, identity: 2)))
+  expectEmpty(s.update(with: MinimalHashableValue(3030, identity: 2)))
+
+  let expected: Set<AnyHashable> = [
+    AnyHashable(MinimalHashableValue(1010, identity: 2)),
+    AnyHashable(MinimalHashableValue(2020, identity: 2)),
+    AnyHashable(MinimalHashableClass(3030, identity: 2)),
+
+    AnyHashable(MinimalHashableClass(1010, identity: 2)),
+    AnyHashable(MinimalHashableClass(2020, identity: 2)),
+    AnyHashable(MinimalHashableValue(3030, identity: 2)),
+  ]
+  expectEqual(expected, s)
+}
+
+SetTests.test("update<Hashable>(with:)/CastTrap")
+  .crashOutputMatches("Could not cast value of type 'main.TestHashableDerivedA'")
+  .crashOutputMatches("to 'main.TestHashableDerivedB'")
+  .code {
+  var s: Set<AnyHashable> = [
+    AnyHashable(TestHashableDerivedA(1010, identity: 1)),
+  ]
+
+  do {
+    let old = s.update(with: TestHashableDerivedA(1010, identity: 2))!
+    expectEqual(1, old.identity)
+  }
+
+  expectCrashLater()
+  s.update(with: TestHashableDerivedB(1010, identity: 3))
+}
+
+SetTests.test("remove<Hashable>(_:)") {
+  var s: Set<AnyHashable> = [
+    AnyHashable(MinimalHashableValue(1010, identity: 1)),
+    AnyHashable(MinimalHashableValue(2020, identity: 1)),
+    AnyHashable(MinimalHashableClass(3030, identity: 1)),
+  ]
+
+  expectEmpty(s.remove(MinimalHashableClass(1010)))
+  expectEmpty(s.remove(MinimalHashableClass(2020)))
+  expectEmpty(s.remove(MinimalHashableValue(3030)))
+
+  expectEqual(3, s.count)
+
+  do {
+    let old = s.remove(MinimalHashableValue(1010, identity: 2))!
+    expectEqual(1010, old.value)
+    expectEqual(1, old.identity)
+  }
+  do {
+    let old = s.remove(MinimalHashableValue(2020, identity: 2))!
+    expectEqual(2020, old.value)
+    expectEqual(1, old.identity)
+  }
+  do {
+    let old = s.remove(MinimalHashableClass(3030, identity: 2))!
+    expectEqual(3030, old.value)
+    expectEqual(1, old.identity)
+  }
+}
+
+SetTests.test("remove<Hashable>(_:)/CastTrap")
+  .crashOutputMatches("Could not cast value of type 'main.TestHashableDerivedA'")
+  .crashOutputMatches("to 'main.TestHashableDerivedB'")
+  .code {
+  var s: Set<AnyHashable> = [
+    AnyHashable(TestHashableDerivedA(1010, identity: 1)),
+    AnyHashable(TestHashableDerivedA(2020, identity: 1)),
+  ]
+
+  do {
+    let old = s.remove(TestHashableDerivedA(1010, identity: 2))!
+    expectEqual(1010, old.value)
+    expectEqual(1, old.identity)
+  }
+
+  expectCrashLater()
+  s.remove(TestHashableDerivedB(2020, identity: 2))
+}
+
+runAllTests()
+