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

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

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)
+  }
+}
+