Merge pull request #4157 from apple/swift3-stdlib-AnyHashable-fixes

[swift-3.0-branch] stdlib and runtime: a bunch of fixes for AnyHashable and id-as-Any

Author: tkremenek

stdlib/private/StdlibUnittest/MinimalTypes.swift.gyb

@@ -103,14 +103,14 @@ public func < (
   return MinimalComparableValue.lessImpl.value(lhs.value, rhs.value)
 }
 
-% for kind in [ 'Value', 'Class' ]:
+% for (kind, decl_keyword) in [ ('Value', 'struct'), ('Class', 'class') ]:
 %   Self = 'MinimalHashable%s' % kind
 
 /// 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} : Equatable, Hashable {
+public ${decl_keyword} ${Self} : Equatable, Hashable {
   public static var timesEqualEqualWasCalled: Int = 0
   public static var timesHashValueWasCalled: Int = 0
 
@@ -148,7 +148,7 @@ public func == (
 
 % end
 
-% for kind in [ 'Value', 'Class' ]:
+% for (kind, decl_keyword) in [ ('Value', 'struct'), ('Class', 'class') ]:
 %   Self = 'GenericMinimalHashable%s' % kind
 
 public var ${Self}_timesEqualEqualWasCalled: Int = 0
@@ -163,7 +163,7 @@ public var ${Self}_hashValueImpl = ResettableValue<(Any) -> Int>(
 ///
 /// This type can be used to check that generic functions don't rely on any
 /// other conformances.
-public struct ${Self}<Wrapped> : Equatable, Hashable {
+public ${decl_keyword} ${Self}<Wrapped> : Equatable, Hashable {
   public var value: Wrapped
   public var identity: Int
 

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -1940,6 +1940,7 @@ public enum TestRunPredicate : CustomStringConvertible {
 public func checkEquatable<Instances : Collection>(
   _ instances: Instances,
   oracle: (Instances.Index, Instances.Index) -> Bool,
+  allowBrokenTransitivity: Bool = false,
   ${TRACE}
 ) where
   Instances.Iterator.Element : Equatable,
@@ -1950,12 +1951,14 @@ public func checkEquatable<Instances : Collection>(
   let indices = Array(instances.indices)
   _checkEquatableImpl(
     Array(instances),
-    oracle: { oracle(indices[$0], indices[$1]) })
+    oracle: { oracle(indices[$0], indices[$1]) },
+    allowBrokenTransitivity: allowBrokenTransitivity)
 }
 
 internal func _checkEquatableImpl<Instance : Equatable>(
   _ instances: [Instance],
   oracle: (Int, Int) -> Bool,
+  allowBrokenTransitivity: Bool = false,
   ${TRACE}
 ) {
   // For each index (which corresponds to an instance being tested) track the
@@ -1988,22 +1991,24 @@ internal func _checkEquatableImpl<Instance : Equatable>(
         "lhs (at index \(i)): \(x)\nrhs (at index \(j)): \(y)",
         stackTrace: ${stackTrace})
 
-      // 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(j, k),
-            "bad oracle: broken transitivity at indices \(i), \(j), \(k)")
-            // No need to check equality between actual values, we will check
-            // them with the checks above.
+      if !allowBrokenTransitivity {
+        // 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(j, k),
+              "bad oracle: broken transitivity at indices \(i), \(j), \(k)")
+              // 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]
         }
-        precondition(transitivityScoreboard[j].value.isEmpty)
-        transitivityScoreboard[j] = transitivityScoreboard[i]
       }
     }
   }
@@ -2024,15 +2029,20 @@ public func checkEquatable<T : Equatable>(
 public func checkHashable<Instances : Collection>(
   _ instances: Instances,
   equalityOracle: (Instances.Index, Instances.Index) -> Bool,
+  allowBrokenTransitivity: Bool = false,
   ${TRACE}
 ) where
   Instances.Iterator.Element : Hashable,
   // FIXME(compiler limitation): these constraints should be applied to
   // associated types of Collection.
   Instances.Indices.Iterator.Element == Instances.Index {
-  
-  checkEquatable(instances, oracle: equalityOracle, ${trace})
-  
+
+  checkEquatable(
+    instances,
+    oracle: equalityOracle,
+    allowBrokenTransitivity: allowBrokenTransitivity,
+    ${trace})
+
   for i in instances.indices {
     let x = instances[i]
     for j in instances.indices {

stdlib/public/core/AnyHashable.swift

@@ -195,9 +195,8 @@ extension Hashable {
 /// Returns a default (non-custom) representation of `self`
 /// as `AnyHashable`.
 ///
-/// Completely ignores the
-/// `_HasCustomAnyHashableRepresentation` conformance, if
-/// any.
+/// Completely ignores the `_HasCustomAnyHashableRepresentation`
+/// conformance, if it exstis.
 @_silgen_name("_swift_stdlib_makeAnyHashableUsingDefaultRepresentation")
 public // COMPILER_INTRINSIC (actually, called from the runtime)
 func _stdlib_makeAnyHashableUsingDefaultRepresentation<H : Hashable>(
@@ -223,14 +222,16 @@ func _convertToAnyHashable<H : Hashable>(_ value: H) -> AnyHashable {
 public // COMPILER_INTRINSIC (actually, called from the runtime)
 func _convertToAnyHashableIndirect<H : Hashable>(
   _ value: H,
-  _ target: UnsafeMutablePointer<AnyHashable>) {
+  _ target: UnsafeMutablePointer<AnyHashable>
+) {
   target.initialize(to: AnyHashable(value))
 }
 
 @_silgen_name("_swift_anyHashableDownCastConditionalIndirect")
 public // COMPILER_INTRINSIC (actually, called from the runtime)
 func _anyHashableDownCastConditionalIndirect<T>(
   _ value: UnsafePointer<AnyHashable>,
-  _ target: UnsafeMutablePointer<T>) -> Bool {
+  _ target: UnsafeMutablePointer<T>
+) -> Bool {
   return value.pointee._downCastConditional(into: target)
-}
+}

stdlib/public/core/Hashable.swift

@@ -98,3 +98,22 @@ public protocol Hashable : _Hashable, Equatable {
   var hashValue: Int { get }
 }
 
+public enum _RuntimeHelpers {}
+
+extension _RuntimeHelpers {
+  @_silgen_name("swift_stdlib_Hashable_isEqual_indirect")
+  public static func Hashable_isEqual_indirect<T : Hashable>(
+    _ lhs: UnsafePointer<T>,
+    _ rhs: UnsafePointer<T>
+  ) -> Bool {
+    return lhs.pointee == rhs.pointee
+  }
+
+  @_silgen_name("swift_stdlib_Hashable_hashValue_indirect")
+  public static func Hashable_hashValue_indirect<T : Hashable>(
+    _ value: UnsafePointer<T>
+  ) -> Int {
+    return value.pointee.hashValue
+  }
+}
+

stdlib/public/stubs/AnyHashableSupport.cpp renamed to stdlib/public/runtime/AnyHashableSupport.cpp

@@ -15,12 +15,12 @@
 #include "swift/Runtime/Concurrent.h"
 #include "swift/Runtime/Debug.h"
 #include "swift/Runtime/Metadata.h"
-#include "../runtime/Private.h"
+#include "Private.h"
+#include "SwiftValue.h"
+#include "SwiftHashableSupport.h"
 
 using namespace swift;
-
-/// The name demangles to "protocol descriptor for Swift.Hashable".
-extern "C" const ProtocolDescriptor _TMps8Hashable;
+using namespace swift::hashable_support;
 
 namespace {
 struct HashableConformanceKey {
@@ -36,6 +36,9 @@ struct HashableConformanceEntry {
 
   /// The highest (closest to the root) type in the superclass chain
   /// that conforms to `Hashable`.
+  ///
+  /// Always non-NULL.  We don't cache negative responses so that we
+  /// don't have to deal with cache invalidation.
   const Metadata *baseTypeThatConformsToHashable;
 
   HashableConformanceEntry(HashableConformanceKey key,
@@ -59,16 +62,26 @@ struct HashableConformanceEntry {
 };
 } // end unnamed namesapce
 
+// FIXME(performance): consider merging this cache into the regular
+// protocol conformance cache.
 static Lazy<ConcurrentMap<HashableConformanceEntry>> HashableConformances;
 
-/// Find the base type that introduces the `Hashable` conformance.
-///
-/// - Precondition: `type` conforms to `Hashable` (not checked).
-static const Metadata *findHashableBaseType(const Metadata *type) {
+template<bool KnownToConformToHashable>
+LLVM_ATTRIBUTE_ALWAYS_INLINE
+static const Metadata *findHashableBaseTypeImpl(const Metadata *type) {
+  // Check the cache first.
   if (HashableConformanceEntry *entry =
           HashableConformances->find(HashableConformanceKey{type})) {
     return entry->baseTypeThatConformsToHashable;
   }
+  if (!KnownToConformToHashable &&
+      !swift_conformsToProtocol(type, &_TMps8Hashable)) {
+    // Don't cache the negative response because we don't invalidate
+    // this cache when a new conformance is loaded dynamically.
+    return nullptr;
+  }
+  // By this point, `type` is known to conform to `Hashable`.
+
   const Metadata *baseTypeThatConformsToHashable = type;
   while (true) {
     const Metadata *superclass =
@@ -84,6 +97,26 @@ static const Metadata *findHashableBaseType(const Metadata *type) {
   return baseTypeThatConformsToHashable;
 }
 
+/// Find the base type that introduces the `Hashable` conformance.
+/// Because the provided type is known to conform to `Hashable`, this
+/// function always returns non-null.
+///
+/// - Precondition: `type` conforms to `Hashable` (not checked).
+const Metadata *swift::hashable_support::findHashableBaseTypeOfHashableType(
+    const Metadata *type) {
+  auto result =
+    findHashableBaseTypeImpl</*KnownToConformToHashable=*/ true>(type);
+  assert(result && "Known-hashable types should have a `Hashable` conformance.");
+  return result;
+}
+
+/// Find the base type that introduces the `Hashable` conformance.
+/// If `type` does not conform to `Hashable`, `nullptr` is returned.
+const Metadata *swift::hashable_support::findHashableBaseType(
+    const Metadata *type) {
+  return findHashableBaseTypeImpl</*KnownToConformToHashable=*/ false>(type);
+}
+
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERFACE
 extern "C" void _swift_stdlib_makeAnyHashableUsingDefaultRepresentation(
   const OpaqueValue *value,
@@ -94,7 +127,7 @@ extern "C" void _swift_stdlib_makeAnyHashableUsingDefaultRepresentation(
 
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERFACE
 extern "C" void _swift_stdlib_makeAnyHashableUpcastingToHashableBaseType(
-  const OpaqueValue *value,
+  OpaqueValue *value,
   const void *anyHashableResultPointer,
   const Metadata *type,
   const WitnessTable *hashableWT
@@ -103,8 +136,35 @@ extern "C" void _swift_stdlib_makeAnyHashableUpcastingToHashableBaseType(
   case MetadataKind::Class:
   case MetadataKind::ObjCClassWrapper:
   case MetadataKind::ForeignClass: {
+#if SWIFT_OBJC_INTEROP
+    id srcObject;
+    memcpy(&srcObject, value, sizeof(id));
+    // Do we have a SwiftValue?
+    if (SwiftValue *srcSwiftValue = getAsSwiftValue(srcObject)) {
+      // If so, extract the boxed value and try to cast it.
+      const Metadata *unboxedType;
+      const OpaqueValue *unboxedValue;
+      std::tie(unboxedType, unboxedValue) =
+          getValueFromSwiftValue(srcSwiftValue);
+
+      if (auto unboxedHashableWT =
+              swift_conformsToProtocol(type, &_TMps8Hashable)) {
+        ValueBuffer unboxedCopyBuf;
+        auto unboxedValueCopy = unboxedType->vw_initializeBufferWithCopy(
+            &unboxedCopyBuf, const_cast<OpaqueValue *>(unboxedValue));
+        _swift_stdlib_makeAnyHashableUpcastingToHashableBaseType(
+            unboxedValueCopy, anyHashableResultPointer, unboxedType,
+            unboxedHashableWT);
+        unboxedType->vw_deallocateBuffer(&unboxedCopyBuf);
+        type->vw_destroy(value);
+        return;
+      }
+    }
+#endif
+
     _swift_stdlib_makeAnyHashableUsingDefaultRepresentation(
-        value, anyHashableResultPointer, findHashableBaseType(type),
+        value, anyHashableResultPointer,
+        findHashableBaseTypeOfHashableType(type),
         hashableWT);
     return;
   }

stdlib/public/runtime/CMakeLists.txt

@@ -33,6 +33,7 @@ else()
 endif()
 
 set(swift_runtime_sources
+    AnyHashableSupport.cpp
     Casting.cpp
     CygwinPort.cpp
     Demangle.cpp

stdlib/public/runtime/Casting.cpp

@@ -29,6 +29,7 @@
 #include "ErrorObject.h"
 #include "ExistentialMetadataImpl.h"
 #include "Private.h"
+#include "SwiftHashableSupport.h"
 #include "../SwiftShims/RuntimeShims.h"
 #include "stddef.h"
 #if SWIFT_OBJC_INTEROP
@@ -40,6 +41,7 @@
 #include <type_traits>
 
 using namespace swift;
+using namespace swift::hashable_support;
 using namespace metadataimpl;
 
 #if SWIFT_OBJC_INTEROP
@@ -905,28 +907,15 @@ static bool isAnyHashableType(const Metadata *type) {
   return false;
 }
 
-SWIFT_CC(swift)
-extern "C"
-void _swift_convertToAnyHashableIndirect(OpaqueValue *source,
-                                         OpaqueValue *destination,
-                                         const Metadata *sourceType,
-                                         const WitnessTable *sourceConformance);
-
-SWIFT_CC(swift)
-extern "C"
-bool _swift_anyHashableDownCastConditionalIndirect(OpaqueValue *source,
-                                                   OpaqueValue *destination,
-                                                   const Metadata *targetType);
-
 /// Perform a dynamic cast from a nominal type to AnyHashable.
 static bool _dynamicCastToAnyHashable(OpaqueValue *destination,
                                       OpaqueValue *source,
                                       const Metadata *sourceType,
                                       const Metadata *targetType,
                                       DynamicCastFlags flags) {
   // Look for a conformance to Hashable.
-  auto hashableConformance =
-    swift_conformsToProtocol(sourceType, &_TMps8Hashable);
+  auto hashableConformance = reinterpret_cast<const HashableWitnessTable *>(
+      swift_conformsToProtocol(sourceType, &_TMps8Hashable));
 
   // If we don't find one, the cast fails.
   if (!hashableConformance) {
@@ -1642,11 +1631,6 @@ extern "C" const ProtocolDescriptor _TMps5Error;
 static const WitnessTable *findErrorWitness(const Metadata *srcType) {
   return swift_conformsToProtocol(srcType, &_TMps5Error);
 }
-
-static const Metadata *getNSErrorMetadata() {
-  return SWIFT_LAZY_CONSTANT(
-    swift_getObjCClassMetadata((const ClassMetadata *)getNSErrorClass()));
-}
 #endif
 
 /// Perform a dynamic cast from an existential type to some kind of