[stdlib] Remove non-obvious conditional Hashable conformances

This removes Hashable conformance for types that do not already implement Equatable:

- CollectionOfOne
- AnyCollection
- DictionaryLiteral

Author: lorentey

stdlib/public/core/CollectionOfOne.swift

@@ -136,23 +136,6 @@ extension CollectionOfOne: RandomAccessCollection, MutableCollection {
   }
 }
 
-@available(swift, introduced: 4.1) // FIXME(conformance-availability)
-extension CollectionOfOne : Equatable where Element : Equatable {
-  @_inlineable // FIXME(sil-serialize-all)
-  @available(swift, introduced: 4.1) // FIXME(conformance-availability)
-  public static func == (lhs: CollectionOfOne, rhs: CollectionOfOne) -> Bool {
-    return lhs._element == rhs._element
-  }
-}
-
-@available(swift, introduced: 4.1) // FIXME(conformance-availability)
-extension CollectionOfOne : Hashable where Element : Hashable {
-  @_inlineable // FIXME(sil-serialize-all)
-  public var hashValue: Int {
-    return _element.hashValue
-  }
-}
-
 extension CollectionOfOne : CustomDebugStringConvertible {
   /// A textual representation of `self`, suitable for debugging.
   @_inlineable // FIXME(sil-serialize-all)

stdlib/public/core/EmptyCollection.swift

@@ -173,12 +173,5 @@ extension EmptyCollection : Equatable {
   }
 }
 
-extension EmptyCollection : Hashable {
-  @_inlineable // FIXME(sil-serialize-all)
-  public var hashValue: Int {
-    return 0
-  }
-}
-
 // @available(*, deprecated, renamed: "EmptyCollection.Iterator")
 public typealias EmptyIterator<T> = EmptyCollection<T>.Iterator

stdlib/public/core/ExistentialCollection.swift.gyb

@@ -1243,30 +1243,3 @@ extension ${Self}: _AnyCollectionProtocol {
   }
 }
 % end
-
-@available(swift, introduced: 4.1) // FIXME(conformance-availability)
-extension AnyCollection : Equatable where Element : Equatable {
-  @_inlineable // FIXME(sil-serialize-all)
-  @available(swift, introduced: 4.1) // FIXME(conformance-availability)
-  public static func == (
-    lhs: AnyCollection<Element>, rhs: AnyCollection<Element>
-  ) -> Bool {
-    if lhs.count != rhs.count {
-      return false
-    }
-    return lhs.elementsEqual(rhs)
-  }
-}
-
-@available(swift, introduced: 4.1) // FIXME(conformance-availability)
-extension AnyCollection : Hashable where Element : Hashable {
-  @_inlineable // FIXME(sil-serialize-all)
-  public var hashValue: Int {
-    // FIXME(ABI)#177: <rdar://problem/18915294> Cache AnyCollection<T> hashValue
-    var result = 0
-    for element in self {
-      result = _combineHashValues(result, element.hashValue)
-    }
-    return result
-  }
-}

stdlib/public/core/Mirror.swift

@@ -761,35 +761,6 @@ extension DictionaryLiteral : RandomAccessCollection {
   }
 }
 
-@available(swift, introduced: 4.1) // FIXME(conformance-availability)
-extension DictionaryLiteral: Equatable where Key: Equatable, Value: Equatable {
-  @_inlineable // FIXME(sil-serialize-all)
-  @available(swift, introduced: 4.1) // FIXME(conformance-availability)
-  public static func == (
-    lhs: DictionaryLiteral<Key, Value>, rhs: DictionaryLiteral<Key, Value>
-  ) -> Bool {
-    if lhs.count != rhs.count {
-      return false
-    }
-    return lhs.elementsEqual(rhs, by: ==)
-  }
-}
-
-@available(swift, introduced: 4.1) // FIXME(conformance-availability)
-extension DictionaryLiteral: Hashable where Key: Hashable, Value: Hashable {
-  @_inlineable // FIXME(sil-serialize-all)
-  public var hashValue: Int {
-    // FIXME(ABI)#177: <rdar://problem/18915294> Issue applies to DictionaryLiteral too
-    var result = 0
-    for element in self {
-      let elementHashValue =
-        _combineHashValues(element.key.hashValue, element.value.hashValue)
-      result = _combineHashValues(result, elementHashValue)
-    }
-    return result
-  }
-}
-
 extension String {
   /// Creates a string representing the given value.
   ///

test/stdlib/DictionaryLiteral.swift

@@ -54,12 +54,3 @@ expectType(DictionaryLiteral<String, NSObject>.self, &hetero1)
 
 var hetero2: DictionaryLiteral = ["a": 1 as NSNumber, "b": "Foo" as NSString]
 expectType(DictionaryLiteral<String, NSObject>.self, &hetero2)
-
-let instances: [DictionaryLiteral<Int, String>] = [
-  [1: "a", 1: "a", 2: "b"],
-  [1: "a", 2: "b", 1: "a"],
-  [2: "b", 1: "a", 1: "a"],
-  [1: "a", 1: "a", 1: "a"]
-]
-checkEquatable(instances, oracle: { $0 == $1 })
-checkHashable(instances, equalityOracle: { $0 == $1 })

validation-test/stdlib/Lazy.swift.gyb

@@ -209,20 +209,6 @@ LazyTestSuite.test("CollectionOfOne/{CustomDebugStringConvertible,CustomReflecta
     c)
 }
 
-LazyTestSuite.test("CollectionOfOne/Equatable") {
-  let c = CollectionOfOne<Int>(42)
-  let d = CollectionOfOne<Int>(43)
-  let instances = [ c, d ]
-  checkEquatable(instances, oracle: { $0 == $1 })
-}
-
-LazyTestSuite.test("CollectionOfOne/Hashable") {
-  let c = CollectionOfOne<Int>(42)
-  let d = CollectionOfOne<Int>(43)
-  let instances = [ c, d ]
-  checkHashable(instances, equalityOracle: { $0 == $1 })
-}
-
 //===----------------------------------------------------------------------===//
 // EmptyCollection
 //===----------------------------------------------------------------------===//
@@ -257,11 +243,6 @@ LazyTestSuite.test("EmptyCollection/Equatable") {
   checkEquatable(instances, oracle: { $0 == $1 })
 }
 
-LazyTestSuite.test("EmptyCollection/Equatable") {
-  let instances = [ EmptyCollection<OpaqueValue<Int>>() ]
-  checkHashable(instances, equalityOracle: { $0 == $1 })
-}
-
 LazyTestSuite.test("EmptyCollection/AssociatedTypes") {
   typealias Subject = EmptyCollection<OpaqueValue<Int>>
   expectRandomAccessCollectionAssociatedTypes(