[SE-0206][test] Update diagnostic tests for Hashable derivation

Author: lorentey

test/Sema/enum_conformance_synthesis.swift

@@ -2,12 +2,15 @@
 // RUN: cp %s %t/main.swift
 // RUN: %target-swift-frontend -typecheck -verify -primary-file %t/main.swift %S/Inputs/enum_conformance_synthesis_other.swift -verify-ignore-unknown
 
+var hasher = Hasher()
+
 enum Foo: CaseIterable {
   case A, B
 }
 
 if Foo.A == .B { }
 var aHash: Int = Foo.A.hashValue
+Foo.A.hash(into: &hasher)
 _ = Foo.allCases
 
 Foo.A == Foo.B // expected-warning {{result of operator '==' is unused}}
@@ -24,6 +27,7 @@ enum Generic<T>: CaseIterable {
 
 if Generic<Foo>.A == .B { }
 var gaHash: Int = Generic<Foo>.A.hashValue
+Generic<Foo>.A.hash(into: &hasher)
 _ = Generic<Foo>.allCases
 
 func localEnum() -> Bool {
@@ -45,6 +49,7 @@ func ==(x: CustomHashable, y: CustomHashable) -> Bool { // expected-note 4 {{non
 
 if CustomHashable.A == .B { }
 var custHash: Int = CustomHashable.A.hashValue
+CustomHashable.A.hash(into: &hasher)
 
 // We still synthesize conforming overloads of '==' and 'hashValue' if
 // explicit definitions don't satisfy the protocol requirements. Probably
@@ -61,6 +66,7 @@ if InvalidCustomHashable.A == .B { }
 var s: String = InvalidCustomHashable.A == .B
 s = InvalidCustomHashable.A.hashValue
 var i: Int = InvalidCustomHashable.A.hashValue
+InvalidCustomHashable.A.hash(into: &hasher)
 
 // Check use of an enum's synthesized members before the enum is actually declared.
 struct UseEnumBeforeDeclaration {
@@ -113,6 +119,10 @@ _ = EnumWithHashablePayload.A(1).hashValue
 _ = EnumWithHashablePayload.B("x", 1).hashValue
 _ = EnumWithHashablePayload.C.hashValue
 
+EnumWithHashablePayload.A(1).hash(into: &hasher)
+EnumWithHashablePayload.B("x", 1).hash(into: &hasher)
+EnumWithHashablePayload.C.hash(into: &hasher)
+
 // ...and they should also inherit equatability from Hashable.
 if EnumWithHashablePayload.A(1) == .B("x", 1) { }
 if EnumWithHashablePayload.A(1) == .C { }
@@ -135,12 +145,13 @@ var genericHashableHash: Int = GenericHashable<String>.A("a").hashValue
 
 // But it should be an error if the generic argument doesn't have the necessary
 // constraints to satisfy the conditions for derivation.
-enum GenericNotHashable<T: Equatable>: Hashable { // expected-error {{does not conform}}
+enum GenericNotHashable<T: Equatable>: Hashable { // expected-error 2 {{does not conform to protocol 'Hashable'}}
   case A(T)
   case B
 }
 if GenericNotHashable<String>.A("a") == .B { }
-var genericNotHashableHash: Int = GenericNotHashable<String>.A("a").hashValue // expected-error {{value of type 'GenericNotHashable<String>' has no member 'hashValue'}}
+let _: Int = GenericNotHashable<String>.A("a").hashValue // No error. hashValue is always synthesized, even if Hashable derivation fails
+GenericNotHashable<String>.A("a").hash(into: &hasher) // expected-error {{value of type 'GenericNotHashable<String>' has no member 'hash'}}
 
 // An enum with no cases should not derive conformance.
 enum NoCases: Hashable {} // expected-error 2 {{does not conform}}

test/Sema/struct_equatable_hashable.swift

@@ -2,13 +2,16 @@
 // RUN: cp %s %t/main.swift
 // RUN: %target-swift-frontend -typecheck -verify -primary-file %t/main.swift %S/Inputs/struct_equatable_hashable_other.swift -verify-ignore-unknown
 
+var hasher = Hasher()
+
 struct Point: Hashable {
   let x: Int
   let y: Int
 }
 
 if Point(x: 1, y: 2) == Point(x: 2, y: 1) { }
-var pointHash: Int = Point(x: 3, y: 5).hashValue
+let pointHash: Int = Point(x: 3, y: 5).hashValue
+Point(x: 3, y: 5).hash(into: &hasher)
 
 Point(x: 1, y: 2) == Point(x: 2, y: 1) // expected-warning {{result of operator '==' is unused}}
 
@@ -24,7 +27,8 @@ struct Pair<T: Hashable>: Hashable {
 let p1 = Pair(first: "a", second: "b")
 let p2 = Pair(first: "a", second: "c")
 if p1 == p2 { }
-var pairHash: Int = p1.hashValue
+let _: Int = p1.hashValue
+p1.hash(into: &hasher)
 
 func localStruct() -> Bool {
   struct Local: Equatable {
@@ -34,22 +38,49 @@ func localStruct() -> Bool {
   return Local(v: 5) == Local(v: 4)
 }
 
-struct CustomHashable: Hashable {
+
+//------------------------------------------------------------------------------
+// Verify compiler can derive hash(into:) implementation from hashValue
+
+struct CustomHashValue: Hashable {
   let x: Int
   let y: Int
 
   var hashValue: Int { return 0 }
 
-  static func ==(x: CustomHashable, y: CustomHashable) -> Bool { return true } // expected-note 2 {{non-matching type}}
+  static func ==(x: CustomHashValue, y: CustomHashValue) -> Bool { return true } // expected-note 2 {{non-matching type}}
+}
+
+if CustomHashValue(x: 1, y: 2) == CustomHashValue(x: 2, y: 3) { }
+let _: Int = CustomHashValue(x: 1, y: 2).hashValue
+CustomHashValue(x: 1, y: 2).hash(into: &hasher)
+
+
+//------------------------------------------------------------------------------
+// Verify compiler can derive hashValue implementation from hash(into:)
+
+struct CustomHashInto: Hashable {
+  let x: Int
+  let y: Int
+
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(x)
+    hasher.combine(y)
+  }
+
+  static func ==(x: CustomHashInto, y: CustomHashInto) -> Bool { return true } // expected-note 2 {{non-matching type}}
 }
 
-if CustomHashable(x: 1, y: 2) == CustomHashable(x: 2, y: 3) { }
-var custHash: Int = CustomHashable(x: 1, y: 2).hashValue
+if CustomHashInto(x: 1, y: 2) == CustomHashInto(x: 2, y: 3) { }
+let _: Int = CustomHashInto(x: 1, y: 2).hashValue
+CustomHashInto(x: 1, y: 2).hash(into: &hasher)
+
 
 // Check use of an struct's synthesized members before the struct is actually declared.
 struct UseStructBeforeDeclaration {
   let eqValue = StructToUseBeforeDeclaration(v: 4) == StructToUseBeforeDeclaration(v: 5)
   let hashValue = StructToUseBeforeDeclaration(v: 1).hashValue
+  let hashInto: (inout Hasher) -> Void = StructToUseBeforeDeclaration(v: 1).hash(into:)
 }
 struct StructToUseBeforeDeclaration: Hashable {
   let v: Int
@@ -58,6 +89,7 @@ struct StructToUseBeforeDeclaration: Hashable {
 // Check structs from another file in the same module.
 if FromOtherFile(v: "a") == FromOtherFile(v: "b") {}
 let _: Int = FromOtherFile(v: "c").hashValue
+FromOtherFile(v: "d").hash(into: &hasher)
 
 func getFromOtherFile() -> AlsoFromOtherFile { return AlsoFromOtherFile(v: 4) }
 if AlsoFromOtherFile(v: 3) == getFromOtherFile() {}
@@ -93,23 +125,26 @@ struct StructIgnoresComputedProperties: Hashable {
 }
 if StructIgnoresComputedProperties(a: 1, b: "a") == StructIgnoresComputedProperties(a: 2, b: "c") {}
 let _: Int = StructIgnoresComputedProperties(a: 3, b: "p").hashValue
-
+StructIgnoresComputedProperties(a: 4, b: "q").hash(into: &hasher)
 
 // Structs should be able to derive conformances based on the conformances of
 // their generic arguments.
 struct GenericHashable<T: Hashable>: Hashable {
   let value: T
 }
 if GenericHashable<String>(value: "a") == GenericHashable<String>(value: "b") { }
-var genericHashableHash: Int = GenericHashable<String>(value: "a").hashValue
+let _: Int = GenericHashable<String>(value: "c").hashValue
+GenericHashable<String>(value: "c").hash(into: &hasher)
 
 // But it should be an error if the generic argument doesn't have the necessary
 // constraints to satisfy the conditions for derivation.
-struct GenericNotHashable<T: Equatable>: Hashable { // expected-error {{does not conform}}
+struct GenericNotHashable<T: Equatable>: Hashable { // expected-error 2 {{does not conform to protocol 'Hashable'}}
   let value: T
 }
 if GenericNotHashable<String>(value: "a") == GenericNotHashable<String>(value: "b") { }
-var genericNotHashableHash: Int = GenericNotHashable<String>(value: "a").hashValue // expected-error {{value of type 'GenericNotHashable<String>' has no member 'hashValue'}}
+let gnh = GenericNotHashable<String>(value: "b")
+let _: Int = gnh.hashValue // No error. hashValue is always synthesized, even if Hashable derivation fails
+gnh.hash(into: &hasher) // expected-error {{value of type 'GenericNotHashable<String>' has no member 'hash'}}
 
 
 // Conformance cannot be synthesized in an extension.
@@ -148,6 +183,30 @@ extension OtherFileNonconforming: Hashable {
 // ...but synthesis in a type defined in another file doesn't work yet.
 extension YetOtherFileNonconforming: Equatable {} // expected-error {{cannot be automatically synthesized in an extension}}
 
+// Verify that we can add Hashable conformance in an extension by only
+// implementing hash(into:)
+struct StructConformsAndImplementsHashIntoInExtension: Equatable {
+  let v: String
+}
+extension StructConformsAndImplementsHashIntoInExtension: Hashable {
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(v)
+  }
+}
+let _: Int = StructConformsAndImplementsHashIntoInExtension(v: "a").hashValue
+StructConformsAndImplementsHashIntoInExtension(v: "b").hash(into: &hasher)
+
+struct GenericHashIntoInExtension<T: Hashable>: Equatable {
+  let value: T
+}
+extension GenericHashIntoInExtension: Hashable {
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
+  }
+}
+let _: Int = GenericHashIntoInExtension<String>(value: "a").hashValue
+GenericHashIntoInExtension(value: "b").hash(into: &hasher)
+
 // FIXME: Remove -verify-ignore-unknown.
 // <unknown>:0: error: unexpected error produced: invalid redeclaration of 'hashValue'
 // <unknown>:0: error: unexpected note produced: candidate has non-matching type '(Foo, Foo) -> Bool'