stdlib: AnyHashable tests: finish tests for CF types

Author: gribozavr

stdlib/private/StdlibUnittest/CMakeLists.txt

@@ -15,6 +15,8 @@ add_swift_library(swiftStdlibUnittest ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_STD
   # filename.
   StdlibUnittest.swift.gyb
 
+  InspectValue.cpp
+  InspectValue.swift
   InterceptTraps.cpp
   LifetimeTracked.swift
   MinimalTypes.swift.gyb

stdlib/private/StdlibUnittest/InspectValue.cpp

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Runtime/Config.h"
+#include "swift/Runtime/Metadata.h"
+
+using namespace swift;
+
+SWIFT_CC(swift)
+extern "C"
+uint32_t swift_StdlibUnittest_getMetadataKindOf(
+    OpaqueValue *value,
+    const Metadata *type
+) {
+  auto result = uint32_t(type->getKind());
+  type->vw_destroy(value);
+  return result;
+}
+

stdlib/private/StdlibUnittest/InspectValue.swift

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// namespace
+public enum SwiftRuntime {
+  public enum MetadataKind : Int {
+    case `class` = 0
+    case `struct` = 1
+    case `enum` = 2
+    case optional = 3
+    case opaque = 8
+    case tuple = 9
+    case function = 10
+    case existential = 12
+    case metatype = 13
+    case objCClassWrapper = 14
+    case existentialMetatype = 15
+    case foreignClass = 16
+    case heapLocalVariable = 64
+    case heapGenericLocalVariable = 65
+    case errorObject = 128
+  }
+
+  @_silgen_name("swift_StdlibUnittest_getMetadataKindOf")
+  static func _metadataKindImpl<T>(of value: T) -> UInt32
+
+  public static func metadataKind<T>(of value: T) -> MetadataKind {
+    return MetadataKind(rawValue: Int(_metadataKindImpl(of: value)))!
+  }
+}
+

stdlib/public/stubs/AnyHashableSupport.cpp

@@ -103,7 +103,6 @@ extern "C" void _swift_stdlib_makeAnyHashableUpcastingToHashableBaseType(
   case MetadataKind::Class:
   case MetadataKind::ObjCClassWrapper:
   case MetadataKind::ForeignClass: {
-    // FIXME(id-as-any): handle ForeignClass.
     _swift_stdlib_makeAnyHashableUsingDefaultRepresentation(
         value, anyHashableResultPointer, findHashableBaseType(type),
         hashableWT);

validation-test/stdlib/AnyHashable.swift.gyb

@@ -1,9 +1,6 @@
 // RUN: %target-run-simple-swiftgyb
 // REQUIRES: executable_test
 
-// FIXME(id-as-any): add tests that use CF objects (is this even
-// possible?)
-
 // FIXME(id-as-any): add tests that use Swift errors and
 // Objective-C errors.
 
@@ -471,27 +468,61 @@ let interestingBitVectorArrays: [[UInt8]] = [
   [0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88],
 ]
 
-AnyHashableTests.test("CFBitVector/Hashable") {
-  let bitVectors = interestingBitVectorArrays.map(CFBitVector.makeImmutable)
+AnyHashableTests.test("AnyHashable with CFBitVector") {
+  let bitVectors: [CFBitVector] =
+    interestingBitVectorArrays.map(CFBitVector.makeImmutable)
   let arrays = bitVectors.map { $0.asArray }
   func isEq(_ lhs: [[UInt8]], _ rhs: [[UInt8]]) -> Bool {
     return zip(lhs, rhs).map { $0 == $1 }.reduce(true, { $0 && $1 })
   }
   expectEqualTest(interestingBitVectorArrays, arrays, sameValue: isEq)
   checkHashable(bitVectors, equalityOracle: { $0 == $1 })
+
+  expectEqual(.foreignClass, SwiftRuntime.metadataKind(of: bitVectors.first!))
+
+  checkHashable(
+    bitVectors.map(AnyHashable.init),
+    equalityOracle: { $0 == $1 })
+
+  let bitVectorsAsAnyObjects: [NSObject] = bitVectors.map {
+    ($0 as AnyObject) as! NSObject
+  }
+  expectEqual(
+    .objCClassWrapper,
+    SwiftRuntime.metadataKind(of: bitVectorsAsAnyObjects.first!))
+  checkHashable(
+    bitVectorsAsAnyObjects.map(AnyHashable.init),
+    equalityOracle: { $0 == $1 })
 }
 
-AnyHashableTests.test("CFMutableBitVector/Hashable") {
+AnyHashableTests.test("AnyHashable with CFMutableBitVector") {
   // CFMutableBitVector inherits the Hashable conformance from
   // CFBitVector.
-  let bitVectors =
+  let bitVectors: [CFMutableBitVector] =
     interestingBitVectorArrays.map(CFMutableBitVector.makeMutable)
   let arrays = bitVectors.map { $0.asArray }
   func isEq(_ lhs: [[UInt8]], _ rhs: [[UInt8]]) -> Bool {
     return zip(lhs, rhs).map { $0 == $1 }.reduce(true, { $0 && $1 })
   }
   expectEqualTest(interestingBitVectorArrays, arrays, sameValue: isEq)
   checkHashable(bitVectors, equalityOracle: { $0 == $1 })
+
+  expectEqual(.foreignClass, SwiftRuntime.metadataKind(of: bitVectors.first!))
+
+  checkHashable(
+    bitVectors.map(AnyHashable.init),
+    equalityOracle: { $0 == $1 })
+
+  let bitVectorsAsAnyObjects: [NSObject] = bitVectors.map {
+    ($0 as AnyObject) as! NSObject
+  }
+  checkHashable(bitVectors, equalityOracle: { $0 == $1 })
+  expectEqual(
+    .objCClassWrapper,
+    SwiftRuntime.metadataKind(of: bitVectorsAsAnyObjects.first!))
+  checkHashable(
+    bitVectorsAsAnyObjects.map(AnyHashable.init),
+    equalityOracle: { $0 == $1 })
 }
 
 #endif