Merge pull request #3554 from apple/stdlib-AnyHashable

Author: swift-ci

include/swift/Runtime/Debug.h

@@ -20,6 +20,7 @@
 #include <llvm/Support/Compiler.h>
 #include <stdint.h>
 #include "swift/Runtime/Config.h"
+#include "swift/Runtime/Metadata.h"
 
 #ifdef SWIFT_HAVE_CRASHREPORTERCLIENT
 
@@ -78,6 +79,13 @@ static inline void crash(const char *message) {
   __builtin_unreachable();
 }
 
+/// Report a corrupted type object.
+LLVM_ATTRIBUTE_NORETURN
+LLVM_ATTRIBUTE_ALWAYS_INLINE // Minimize trashed registers
+static inline void _failCorruptType(const Metadata *type) {
+  swift::crash("Corrupt Swift type object");
+}
+
 // swift::fatalError() halts with a crash log message, 
 // but makes no attempt to preserve register state.
 LLVM_ATTRIBUTE_NORETURN

include/swift/Runtime/Metadata.h

@@ -3447,6 +3447,10 @@ void swift_registerTypeMetadataRecords(const TypeMetadataRecord *begin,
 std::string nameForMetadata(const Metadata *type,
                             bool qualified = true);
 
+SWIFT_RUNTIME_STDLIB_INTERFACE
+extern "C"
+const Metadata *_swift_class_getSuperclass(const Metadata *theClass);
+
 } // end namespace swift
 
 #pragma clang diagnostic pop

stdlib/private/StdlibUnittest/MinimalTypes.swift.gyb

@@ -148,6 +148,51 @@ public func == (
 
 % end
 
+% for kind in [ 'Value', 'Class' ]:
+%   Self = 'GenericMinimalHashable%s' % kind
+
+public var ${Self}_timesEqualEqualWasCalled: Int = 0
+public var ${Self}_timesHashValueWasCalled: Int = 0
+
+public var ${Self}_equalImpl = ResettableValue<(Any, Any) -> Bool>(
+  { _, _ in fatalError("${Self}_equalImpl is not set yet"); () })
+public var ${Self}_hashValueImpl = ResettableValue<(Any) -> Int>(
+  { _ in fatalError("${Self}_hashValueImpl is not set yet"); () })
+
+/// A type that conforms only to `Equatable` and `Hashable`.
+///
+/// This type can be used to check that generic functions don't rely on any
+/// other conformances.
+public struct ${Self}<Wrapped> : Equatable, Hashable {
+  public var value: Wrapped
+  public var identity: Int
+
+  public init(_ value: Wrapped) {
+    self.value = value
+    self.identity = 0
+  }
+
+  public init(_ value: Wrapped, identity: Int) {
+    self.value = value
+    self.identity = identity
+  }
+
+  public var hashValue: Int {
+    ${Self}_timesHashValueWasCalled += 1
+    return ${Self}_hashValueImpl.value(value)
+  }
+}
+
+public func == <Wrapped>(
+  lhs: ${Self}<Wrapped>,
+  rhs: ${Self}<Wrapped>
+) -> Bool {
+  ${Self}_timesEqualEqualWasCalled += 1
+  return ${Self}_equalImpl.value(lhs.value, rhs.value)
+}
+
+% end
+
 /// A type that conforms only to `Equatable`, `Comparable`, and `Strideable`.
 ///
 /// This type can be used to check that generic functions don't rely on any

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -1939,56 +1939,71 @@ public func checkEquatable<Instances : Collection>(
   Instances.Iterator.Element : Equatable,
   // FIXME(compiler limitation): these constraints should be applied to
   // associated types of Collection.
-  Instances.Indices.Iterator.Element == Instances.Index {
+  Instances.Indices.Iterator.Element == Instances.Index
+{
+  let indices = Array(instances.indices)
+  _checkEquatableImpl(
+    Array(instances),
+    oracle: { oracle(indices[$0], indices[$1]) })
+}
+
+internal func _checkEquatableImpl<Instance : Equatable>(
+  _ instances: [Instance],
+  oracle: (Int, Int) -> Bool,
+  ${TRACE}
+) {
+  // For each index (which corresponds to an instance being tested) track the
+  // set of equal instances.
+  var transitivityScoreboard: [Box<Set<Int>>] =
+    instances.indices.map { _ in Box(Set()) }
 
   // TODO: swift-3-indexing-model: add tests for this function.
   for i in instances.indices {
-    expectTrue(oracle(i, i), "bad oracle: broken reflexivity at index \(i)")
     let x = instances[i]
-    // Reflexivity
-    expectEqual(x, x, ${trace})
+    expectTrue(oracle(i, i), "bad oracle: broken reflexivity at index \(i)")
+
     for j in instances.indices {
+      let y = instances[j]
+
       let predictedXY = oracle(i, j)
       expectEqual(
         predictedXY, oracle(j, i),
         "bad oracle: broken symmetry between indices \(i), \(j)")
-      
-      let y = instances[j]
 
-      let xy = x == y
+      let isEqualXY = x == y
       expectEqual(
-        predictedXY, xy,
+        predictedXY, isEqualXY,
         "lhs (at index \(i)): \(x)\nrhs (at index \(j)): \(y)",
         stackTrace: ${stackTrace})
 
-      // Not-equal is an inverse of equal
+      // Not-equal is an inverse of equal.
       expectNotEqual(
-        xy, x != y,
-        "lhs (at index \(i)): \(x)\nrhs (at index \(j)): \(y)",
-        stackTrace: ${stackTrace})
-
-      // Symmetry
-      expectEqual(
-        xy, y == x,
+        isEqualXY, x != y,
         "lhs (at index \(i)): \(x)\nrhs (at index \(j)): \(y)",
         stackTrace: ${stackTrace})
 
-      for k in instances.indices {
-        let z = instances[k]
-        // Transitivity
-        let predictedYZ = oracle(j, k)
-        if predictedXY && predictedYZ {
+      // Check transitivity of the predicate represented by the oracle.
+      // If we are adding the instance `j` into an equivalence set, check that
+      // it is equal to every other instance in the set.
+      if predictedXY && i < j && transitivityScoreboard[i].value.insert(j).inserted {
+        if transitivityScoreboard[i].value.count == 1 {
+          transitivityScoreboard[i].value.insert(i)
+        }
+        for k in transitivityScoreboard[i].value {
           expectTrue(
-            oracle(i, k),
+            oracle(j, k),
             "bad oracle: broken transitivity at indices \(i), \(j), \(k)")
-          expectEqual(y, z, ${trace})
-          expectEqual(x, z, ${trace})
+            // No need to check equality between actual values, we will check
+            // them with the checks above.
         }
+        precondition(transitivityScoreboard[j].value.isEmpty)
+        transitivityScoreboard[j] = transitivityScoreboard[i]
       }
     }
   }
 }
 
+
 public func checkEquatable<T : Equatable>(
   _ expectedEqual: Bool, _ lhs: T, _ rhs: T, ${TRACE}
 ) {

stdlib/public/SDK/Foundation/AffineTransform.swift

@@ -293,4 +293,10 @@ extension AffineTransform : _ObjectiveCBridgeable {
     }
 }
 
+extension NSAffineTransform : _HasCustomAnyHashableRepresentation {
+    public func _toCustomAnyHashable() -> AnyHashable? {
+        return AnyHashable(self as AffineTransform)
+    }
+}
+
 #endif

stdlib/public/SDK/Foundation/CMakeLists.txt

@@ -27,6 +27,7 @@ add_swift_library(swiftFoundation ${SWIFT_SDK_OVERLAY_LIBRARY_BUILD_TYPES} IS_SD
   NotificationThunks.m
   NSStringEncodings.swift
   PersonNameComponents.swift
+  TypePreservingNSNumber.mm
   URL.swift
   URLComponents.swift
   URLRequest.swift

stdlib/public/SDK/Foundation/Calendar.swift

@@ -1128,3 +1128,9 @@ extension Calendar : _ObjectiveCBridgeable {
     }
 }
 
+extension NSCalendar : _HasCustomAnyHashableRepresentation {
+    public func _toCustomAnyHashable() -> AnyHashable? {
+        return AnyHashable(self as Calendar)
+    }
+}
+

stdlib/public/SDK/Foundation/CharacterSet.swift

@@ -463,6 +463,12 @@ extension CharacterSet : _ObjectiveCBridgeable {
 
 }
 
+extension NSCharacterSet : _HasCustomAnyHashableRepresentation {
+    public func _toCustomAnyHashable() -> AnyHashable? {
+        return AnyHashable(self as CharacterSet)
+    }
+}
+
 extension _SwiftNSCharacterSet {
 
     // Stubs

stdlib/public/SDK/Foundation/Data.swift

@@ -723,6 +723,12 @@ extension Data : _ObjectiveCBridgeable {
     }
 }
 
+extension NSData : _HasCustomAnyHashableRepresentation {
+    public func _toCustomAnyHashable() -> AnyHashable? {
+        return AnyHashable(self as Data)
+    }
+}
+
 /// A NSData subclass that uses Swift reference counting.
 ///
 /// This subclass implements the API of NSData by holding an instance and forwarding all implementation to that object.

stdlib/public/SDK/Foundation/Date.swift

@@ -262,6 +262,12 @@ extension Date : _ObjectiveCBridgeable {
     }
 }
 
+extension NSDate : _HasCustomAnyHashableRepresentation {
+    public func _toCustomAnyHashable() -> AnyHashable? {
+        return AnyHashable(self as Date)
+    }
+}
+
 extension Date : CustomPlaygroundQuickLookable {
     var summary: String {
         let df = DateFormatter()

stdlib/public/SDK/Foundation/DateComponents.swift

@@ -345,3 +345,9 @@ extension DateComponents : _ObjectiveCBridgeable {
     }
 }
 
+extension NSDateComponents : _HasCustomAnyHashableRepresentation {
+    public func _toCustomAnyHashable() -> AnyHashable? {
+        return AnyHashable(self as DateComponents)
+    }
+}
+

stdlib/public/SDK/Foundation/DateInterval.swift

@@ -219,3 +219,11 @@ extension DateInterval : _ObjectiveCBridgeable {
         return result!
     }
 }
+
+@available(OSX 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *)
+extension NSDateInterval : _HasCustomAnyHashableRepresentation {
+    public func _toCustomAnyHashable() -> AnyHashable? {
+        return AnyHashable(self as DateInterval)
+    }
+}
+