[cxx-interop] Add Hashable conformance to imported enums (#76940)

* [cxx-interop] Add Hashable conformance to imported enums

Previously, imported enums only conformed to RawRepresentable and Equatable,
so they could not be used as members of a Set or keys of a Dictionary.
This patch adds Hashable conformance to give them that ability,
as well as some test cases to clarify the expected behavior.
Existing test cases are updated to reflect this new conformance.

rdar://129713687

Author: j-hui

lib/ClangImporter/ImportDecl.cpp

@@ -1637,7 +1637,8 @@ namespace {
 
         synthesizer.makeStructRawValued(
             structDecl, underlyingType,
-            {KnownProtocolKind::RawRepresentable, KnownProtocolKind::Equatable},
+            {KnownProtocolKind::RawRepresentable, KnownProtocolKind::Equatable,
+             KnownProtocolKind::Hashable},
             options, /*setterAccess=*/AccessLevel::Public);
 
         result = structDecl;

test/ClangImporter/Inputs/SwiftPrivateAttr.txt

@@ -56,21 +56,21 @@ struct __PrivS2 {
   var value: Int32
 }
 var __PrivAnonymousA: Int { get }
-struct E0 : Equatable, RawRepresentable {
+struct E0 : Hashable, Equatable, RawRepresentable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32
   typealias RawValue = UInt32
 }
 var __E0PrivA: E0 { get }
-struct __PrivE1 : Equatable, RawRepresentable {
+struct __PrivE1 : Hashable, Equatable, RawRepresentable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32
   typealias RawValue = UInt32
 }
 var __PrivE1A: __PrivE1 { get }
-struct __PrivE2 : Equatable, RawRepresentable {
+struct __PrivE2 : Hashable, Equatable, RawRepresentable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32

test/Interop/Cxx/class/access-specifiers-module-interface.swift

@@ -11,7 +11,7 @@
 // CHECK-NEXT:   struct PublicStruct {
 // CHECK-NEXT:     init()
 // CHECK-NEXT:   }
-// CHECK-NEXT:   struct PublicEnum : Equatable, RawRepresentable {
+// CHECK-NEXT:   struct PublicEnum : Hashable, Equatable, RawRepresentable {
 // CHECK-NEXT:     init(_ rawValue: [[ENUM_UNDERLYING_TYPE:Int32|UInt32]])
 // CHECK-NEXT:     init(rawValue: [[ENUM_UNDERLYING_TYPE]])
 // CHECK-NEXT:     var rawValue: [[ENUM_UNDERLYING_TYPE]]

test/Interop/Cxx/class/inheritance/sub-types-module-interface.swift

@@ -10,7 +10,7 @@
 // CHECK-NEXT:     case ecb
 // CHECK-NEXT:     case ecc
 // CHECK-NEXT:   }
-// CHECK-NEXT:   struct Enum : Equatable, RawRepresentable {
+// CHECK-NEXT:   struct Enum : Hashable, Equatable, RawRepresentable {
 // CHECK-NEXT:     init(_ rawValue: {{UInt32|Int32}})
 // CHECK-NEXT:     init(rawValue: {{UInt32|Int32}})
 // CHECK-NEXT:     var rawValue: {{UInt32|Int32}}

test/Interop/Cxx/class/nested-records-module-interface.swift

@@ -17,7 +17,7 @@
 // CHECK: }
 
 // CHECK: struct U3 {
-// CHECK:   struct E1 : Equatable, RawRepresentable {
+// CHECK:   struct E1 : Hashable, Equatable, RawRepresentable {
 // CHECK:     typealias RawValue = {{UInt32|Int32}}
 // CHECK:   }
 // CHECK: }
@@ -29,7 +29,7 @@
 
 // CHECK: struct S6 {
 // CHECK:   init()
-// CHECK:   struct E3 : Equatable, RawRepresentable {
+// CHECK:   struct E3 : Hashable, Equatable, RawRepresentable {
 // CHECK:     typealias RawValue = {{UInt32|Int32}}
 // CHECK:   }
 // CHECK: }
@@ -50,7 +50,7 @@
 
 // CHECK: struct S10 {
 // CHECK:   struct U8 {
-// CHECK:     struct E4 : Equatable, RawRepresentable {
+// CHECK:     struct E4 : Hashable, Equatable, RawRepresentable {
 // CHECK:       typealias RawValue = {{UInt32|Int32}}
 // CHECK:     }
 // CHECK:   }

test/Interop/Cxx/enum/bool-enums-module-interface.swift

@@ -2,7 +2,7 @@
 
 // TODO: these should be enums eventually (especially the enum class).
 
-// CHECK:       struct Maybe : Equatable, RawRepresentable {
+// CHECK:       struct Maybe : Hashable, Equatable, RawRepresentable {
 // CHECK-NEXT:    init(_ rawValue: Bool)
 // CHECK-NEXT:    init(rawValue: Bool)
 // CHECK-NEXT:    var rawValue: Bool
@@ -11,7 +11,7 @@
 // CHECK:       var No: Maybe { get }
 // CHECK:       var Yes: Maybe { get }
 
-// CHECK:       struct BinaryNumbers : Equatable, RawRepresentable {
+// CHECK:       struct BinaryNumbers : Hashable, Equatable, RawRepresentable {
 // CHECK-NEXT:    init(_ rawValue: Bool)
 // CHECK-NEXT:    init(rawValue: Bool)
 // CHECK-NEXT:	  var rawValue: Bool
@@ -31,7 +31,7 @@
 // CHECK:       struct WrapperStruct {
 // CHECK-NEXT:    init()
 // TODO: where is "A" and "B"? They should be member variables.
-// CHECK-NEXT:    struct InnerBoolEnum : Equatable, RawRepresentable {
+// CHECK-NEXT:    struct InnerBoolEnum : Hashable, Equatable, RawRepresentable {
 // CHECK-NEXT:      init(_ rawValue: Bool)
 // CHECK-NEXT:      init(rawValue: Bool)
 // CHECK-NEXT:      var rawValue: Bool

test/Interop/Cxx/enum/hashable-enums-typecheck.swift

@@ -0,0 +1,21 @@
+// RUN: %target-typecheck-verify-swift -I %S/Inputs -enable-experimental-cxx-interop
+
+import TypedUntypedEnums
+
+let _: Set = [kBlue, kGreen]        // construct a set from blue and green
+let _: Set = [kBlue, kBlue]         // construct a valid set from two blues
+
+// Not allowed to mix and match elements of a set.
+let _: Set = [kBlue, kTwo]          // expected-error {{conflicting arguments to generic parameter 'Element' ('Int' vs. 'Color')}}
+let _: Set = [kBlue, Pet.dogcow]    // expected-error {{conflicting arguments to generic parameter 'Element' ('Pet' vs. 'Color')}}
+
+let s: Set<Pet> = []                // construct an empty, type-annotated set
+let _ = s.contains(Pet.goat)        // query the empty set using a key
+let _ = s.contains(kTwo)            // expected-error {{cannot convert value of type 'Int' to expected argument type 'Pet'}}
+
+// Untyped enums can be used interchangeably with integers
+let _: Set = [kFour, kTwo]          // construct a set from untyped enum
+let _: Set = [kFour, kTwo, 0]       // construct a set that mixes untyped enums and integers
+
+let _ = [Pet.goat: "baa", Pet.dogcow: "moo"]                        // dictionaries are fine too
+let _: [AnyHashable: String] = [Pet.goat: "baa", kFour: "meow"]     // even heterogeneous ones

test/Interop/Cxx/enum/hashable-enums.swift

@@ -0,0 +1,87 @@
+// RUN: %target-run-simple-swift(-cxx-interoperability-mode=default -Xfrontend -disable-availability-checking -I %S/Inputs)
+// REQUIRES: executable_test
+
+import StdlibUnittest
+import TypedUntypedEnums
+
+// A helper for hashing Hasable values.
+func getHash<H>(_ x: H) -> Int where H: Hashable {
+    var h = Hasher()
+    h.combine(x)
+    return h.finalize()
+}
+
+let Colors = [kRed, kBlue, kGreen, kYellow]
+let Numbers = [kOne, kTwo, kThree, kFour]
+let Pets = [Pet.goat, Pet.cat, Pet.dogcow, Pet.rabbit]
+
+var HashableEnumsTestSuite = TestSuite("Enums are hashable")
+
+HashableEnumsTestSuite.test("Hashes preserve equality") {
+    for m in 0..<Colors.count {
+        for n in 0..<Colors.count {
+          if m == n {
+              expectEqual(getHash(Colors[m]), getHash(Colors[n]))
+          } else {
+              expectNotEqual(getHash(Colors[m]), getHash(Colors[n]))
+          }
+        }
+    }
+
+    for m in 0..<Numbers.count {
+        for n in 0..<Numbers.count {
+          if m == n {
+              expectEqual(getHash(Numbers[m]), getHash(Numbers[n]))
+          } else {
+              expectNotEqual(getHash(Numbers[m]), getHash(Numbers[n]))
+          }
+        }
+    }
+
+    for m in 0..<Pets.count {
+        for n in 0..<Pets.count {
+          if m == n {
+              expectEqual(getHash(Pets[m]), getHash(Pets[n]))
+          } else {
+              expectNotEqual(getHash(Pets[m]), getHash(Pets[n]))
+          }
+        }
+    }
+}
+
+HashableEnumsTestSuite.test("Untyped enums hash using underlying value") {
+    for m in 1...4 {
+        for n in 1...Numbers.count {
+            let number = Numbers[n - 1]
+            if m == n {
+                expectEqual(getHash(m), getHash(number))
+            } else {
+                expectNotEqual(getHash(m), getHash(number))
+            }
+        }
+    }
+}
+
+HashableEnumsTestSuite.test("Typed enums and class enums hash using other info") {
+    // The raw values of these enum members are known:
+    expectEqual(kRed.rawValue, 0)
+    expectEqual(kYellow.rawValue, 10)
+    expectEqual(Pet.goat.rawValue, 5)
+    expectEqual(Pet.cat.rawValue, 15)
+
+    // But the Hashable implementation uses more than the raw value to compute the hash:
+    expectNotEqual(getHash(kRed), getHash(0))
+    expectNotEqual(getHash(kYellow), getHash(10))
+    expectNotEqual(getHash(Pet.goat), getHash(5))
+    expectNotEqual(getHash(Pet.cat), getHash(15))
+}
+
+HashableEnumsTestSuite.test("Sets work as expected") {
+    let s: Set = [kRed, kBlue, kRed, kRed]
+    assert(s.contains(kRed))
+    assert(s.contains(kBlue))
+    assert(!s.contains(kGreen))
+    assert(s.count == 2) // kRed should have been deduplicated
+}
+
+runAllTests()

test/Interop/Cxx/enum/nested-enums-module-interface.swift

@@ -1,7 +1,7 @@
 // RUN: %target-swift-ide-test -print-module -module-to-print=NestedEnums -I %S/Inputs -source-filename=x -enable-experimental-cxx-interop | %FileCheck %s
 
 // CHECK: enum ns {
-// CHECK:  struct EnumInNS : Equatable, RawRepresentable {
+// CHECK:  struct EnumInNS : Hashable, Equatable, RawRepresentable {
 // CHECK:  }
 // CHECK-NEXT:  static var kA: ns.EnumInNS { get }
 // CHECK-NEXT:  static var kB: ns.EnumInNS { get }
@@ -10,7 +10,7 @@
 // CHECK:    case scopeB
 // CHECK-NEXT:  }
 // CHECK-NEXT:  enum nestedNS {
-// CHECK-NEXT:    struct EnumInNestedNS : Equatable, RawRepresentable {
+// CHECK-NEXT:    struct EnumInNestedNS : Hashable, Equatable, RawRepresentable {
 // CHECK:    }
 // CHECK-NEXT:    static var kNestedA: ns.nestedNS.EnumInNestedNS { get }
 // CHECK-NEXT:    static var kNestedB: ns.nestedNS.EnumInNestedNS { get }