Allow Equatable: ~Copyable

Author: airspeedswift

stdlib/public/core/Equatable.swift

@@ -164,7 +164,7 @@
 ///     let c = a
 ///     print(c === a, c === b, separator: ", ")
 ///     // Prints "true, false"
-public protocol Equatable {
+public protocol Equatable: ~Copyable {
   /// Returns a Boolean value indicating whether two values are equal.
   ///
   /// Equality is the inverse of inequality. For any values `a` and `b`,
@@ -173,10 +173,10 @@ public protocol Equatable {
   /// - Parameters:
   ///   - lhs: A value to compare.
   ///   - rhs: Another value to compare.
-  static func == (lhs: Self, rhs: Self) -> Bool
+  static func == (lhs: borrowing Self, rhs: borrowing Self) -> Bool
 }
 
-extension Equatable {
+extension Equatable where Self: ~Copyable {
   /// Returns a Boolean value indicating whether two values are not equal.
   ///
   /// Inequality is the inverse of equality. For any values `a` and `b`, `a != b`
@@ -190,8 +190,9 @@ extension Equatable {
   ///   - rhs: Another value to compare.
   // transparent because sometimes types that use this generate compile-time
   // warnings, e.g. that an expression always evaluates to true
+  @_preInverseGenerics
   @_transparent
-  public static func != (lhs: Self, rhs: Self) -> Bool {
+  public static func != (lhs: borrowing Self, rhs: borrowing Self) -> Bool {
     return !(lhs == rhs)
   }
 }

test/Concurrency/member_operator_adjustment.swift

@@ -2,6 +2,6 @@
 
 // CHECK: (func_decl decl_context={{.*}} range={{.*}} "test(v:)"
 func test<T: Equatable>(v: T) {
-  // CHECK: (function_conversion_expr implicit type="@Sendable (T.Type) -> (T, T) -> Bool"
+  // CHECK: (function_conversion_expr implicit type="@Sendable (T.Type) -> (borrowing T, borrowing T) -> Bool"
   _ = v == v
 }

test/Constraints/anyhashable_and_operator_filtering.swift

@@ -26,5 +26,5 @@ func test(arr: [any P]) {
 // CHECK: sil private [ossa] @$s34anyhashable_and_operator_filtering4test3arrySayAA1P_pG_tFyAaD_pXEfU_
 // CHECK: [[LHS_ARG:%.*]] = alloc_stack $E
 // CHECK: [[RHS_ARG:%.*]] = alloc_stack $E
-// CHECK: [[GENERIC_OP:%.*]] = witness_method $E, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool
+// CHECK: [[GENERIC_OP:%.*]] = witness_method $E, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool
 // CHECK-NEXT: apply [[GENERIC_OP]]<E>([[LHS_ARG]], [[RHS_ARG]], {{.*}})

test/Constraints/rdar158063151.swift

@@ -8,7 +8,7 @@ struct Value: Equatable, ExpressibleByNilLiteral {
 }
 
 // CHECK-LABEL: sil hidden [ossa] @$s13rdar1580631514test1vyAA5ValueV_tF : $@convention(thin) (Value) -> ()
-// CHECK: [[EQUALS_REF:%.*]] = witness_method $Value, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool
+// CHECK: [[EQUALS_REF:%.*]] = witness_method $Value, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool
 // CHECK-NEXT: apply [[EQUALS_REF]]<Value>({{.*}})
 func test(v: Value) {
   _ = v == nil

test/Generics/tuple-conformances.swift

@@ -93,7 +93,37 @@ func useConformance() {
 
 ////
 
-extension Tuple: Equatable where repeat each Element: Equatable {
+
+// Tuples cannot yet have conformances conditional on more than one thing,
+// and ~Copyable packs aren't yet supported, so redefining these protocols
+// as copyable-only versions
+
+public protocol CopyableEquatable {
+  static func ==(lhs: Self, rhs: Self) -> Bool
+}
+
+public protocol CopyableComparable: CopyableEquatable {
+  static func <(lhs: Self, rhs: Self) -> Bool
+}
+
+public protocol CopyableHashable: CopyableEquatable {
+  func hash(into hasher: inout Hasher)
+}
+
+public extension CopyableEquatable {
+    static func !=(lhs: Self, rhs: Self) -> Bool {
+        !(lhs == rhs)
+    }
+}
+
+extension CopyableComparable {
+    static func >(lhs: Self, rhs: Self) -> Bool {
+        !(lhs > rhs) && lhs != rhs
+    }
+}
+
+
+extension Tuple: CopyableEquatable where repeat each Element: CopyableEquatable {
   // FIXME: Hack
   @_disfavoredOverload
   public static func ==(lhs: Self, rhs: Self) -> Bool {
@@ -104,15 +134,15 @@ extension Tuple: Equatable where repeat each Element: Equatable {
   }
 }
 
-extension Tuple: Hashable where repeat each Element: Hashable {
+extension Tuple: CopyableHashable where repeat each Element: CopyableHashable {
   public func hash(into hasher: inout Hasher) {
     for elt in repeat each self {
       elt.hash(into: &hasher)
     }
   }
 }
 
-extension Tuple: Comparable where repeat each Element: Comparable {
+extension Tuple: CopyableComparable where repeat each Element: CopyableComparable {
   // FIXME: Hack
   @_disfavoredOverload
   public static func <(lhs: Self, rhs: Self) -> Bool {

test/IRGen/async/run-call-genericEquatable-x2-to-bool.sil

@@ -25,7 +25,7 @@ sil public_external @printBool : $@convention(thin) (Bool) -> ()
 sil hidden @genericEquatableAndGenericEquatableToBool : $@async @convention(thin) <T where T : Equatable> (@in_guaranteed T, @in_guaranteed T) -> Bool {
 bb0(%0 : $*T, %1 : $*T):
   %4 = metatype $@thick T.Type
-  %5 = witness_method $T, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool : $@convention(witness_method: Equatable) <τ_0_0 where τ_0_0 : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0, @thick τ_0_0.Type) -> Bool
+  %5 = witness_method $T, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool : $@convention(witness_method: Equatable) <τ_0_0 where τ_0_0 : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0, @thick τ_0_0.Type) -> Bool
   %6 = apply %5<T>(%0, %1, %4) : $@convention(witness_method: Equatable) <τ_0_0 where τ_0_0 : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0, @thick τ_0_0.Type) -> Bool
   return %6 : $Bool
 }

test/Parse/inverses.swift

@@ -19,7 +19,7 @@ func more() {
   let _: ~AnyObject // expected-error {{type 'AnyObject' cannot be suppressed}}
 }
 
-struct S4: ~(Copyable & Equatable) {} // expected-error {{conformance to 'Equatable' cannot be suppressed}}
+struct S4: ~(Copyable & Equatable) {} // expected-error {{type 'Copyable & Equatable' cannot be suppressed}}
 
 func blah<T>(_ t: borrowing T) where T: ~Copyable,
                                      T: ~Hashable {}  // expected-error@:41 {{type 'Hashable' cannot be suppressed}}

test/SILGen/enum_equatable_witness.swift

@@ -48,15 +48,15 @@ public enum Alphabet : String {
 
 // CHECK-LABEL: sil [ossa] @$s4main14check_alphabetySiAA8AlphabetOF : $@convention(thin) (Alphabet) -> Int {
 public func check_alphabet(_ state : Alphabet) -> Int {
-  // FRAGILE: witness_method $Alphabet, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool
-  // RESILIENT: witness_method $Alphabet, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool
+  // FRAGILE: witness_method $Alphabet, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool
+  // RESILIENT: witness_method $Alphabet, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool
   return state == .E ? 1 : 0
 }
 
 // CHECK-LABEL: sil [ossa] @$s4main9compareItySbAA8AlphabetO_ADtF : $@convention(thin) (Alphabet, Alphabet) -> Bool {
 public func compareIt(_ state : Alphabet, _ rhs: Alphabet) -> Bool {
-  // FRAGILE: witness_method $Alphabet, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool
-  // RESILIENT: witness_method $Alphabet, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool
+  // FRAGILE: witness_method $Alphabet, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool
+  // RESILIENT: witness_method $Alphabet, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool
   return state == rhs
 }
 
@@ -67,14 +67,14 @@ public enum AlphabetInt : Int {
 
 // CHECK-LABEL: sil [ossa] @$s4main18check_alphabet_intySiAA11AlphabetIntOF : $@convention(thin) (AlphabetInt) -> Int {
 public func check_alphabet_int(_ state : AlphabetInt) -> Int {
-  // FRAGILE: witness_method $AlphabetInt, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool
-  // RESILIENT: witness_method $AlphabetInt, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool
+  // FRAGILE: witness_method $AlphabetInt, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool
+  // RESILIENT: witness_method $AlphabetInt, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool
   return state == .E ? 1 : 0
 }
 
 // CHECK-LABEL: sil [ossa] @$s4main9compareItySbAA11AlphabetIntO_ADtF : $@convention(thin) (AlphabetInt, AlphabetInt) -> Bool {
 public func compareIt(_ state : AlphabetInt, _ rhs: AlphabetInt) -> Bool {
-  // FRAGILE: witness_method $AlphabetInt, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool
-  // RESILIENT: witness_method $AlphabetInt, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool
+  // FRAGILE: witness_method $AlphabetInt, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool
+  // RESILIENT: witness_method $AlphabetInt, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool
   return state == rhs
 }

test/SILGen/pack_iteration.swift

@@ -85,8 +85,8 @@ func iterateTrivial<each Element>(over element: repeat each Element) {
 // CHECK: tuple_pack_element_addr [[DYN_PACK_IDX]] of [[STACK1]] : $*(repeat each Element) as $*@pack_element("[[UUID]]") each Element
 // CHECK: tuple_pack_element_addr [[DYN_PACK_IDX]] of [[STACK2]] : $*(repeat each Element) as $*@pack_element("[[UUID]]") each Element
 // CHECK: [[METATYPE:%.*]] = metatype $@thick (@pack_element("[[UUID]]") each Element).Type
-// CHECK: [[WITNESS_METHOD:%.*]] = witness_method $@pack_element("[[UUID]]") each Element, #Equatable."==" : <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool, [[OPEN_PACK_ELT]] : $Builtin.SILToken : $@convention(witness_method: Equatable) <τ_0_0 where τ_0_0 : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0, @thick τ_0_0.Type) -> Bool
-// CHECK: apply [[WITNESS_METHOD]]<@pack_element("[[UUID]]") each Element>([[STACK_LEFT]], [[STACK_RIGHT]], [[METATYPE]]) : $@convention(witness_method: Equatable) <τ_0_0 where τ_0_0 : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0, @thick τ_0_0.Type) -> Bool
+// CHECK: [[WITNESS_METHOD:%.*]] = witness_method $@pack_element("[[UUID]]") each Element, #Equatable."==" : <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool, [[OPEN_PACK_ELT]] : $Builtin.SILToken : $@convention(witness_method: Equatable) <τ_0_0 where τ_0_0 : Equatable, τ_0_0 : ~Copyable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0, @thick τ_0_0.Type) -> Bool
+// CHECK: apply [[WITNESS_METHOD]]<@pack_element("[[UUID]]") each Element>([[STACK_LEFT]], [[STACK_RIGHT]], [[METATYPE]]) : $@convention(witness_method: Equatable) <τ_0_0 where τ_0_0 : Equatable, τ_0_0 : ~Copyable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0, @thick τ_0_0.Type) -> Bool
 //
 // CHECK: } // end sil function '$s14pack_iteration11equalTuples3lhs3rhsSbxxQp_t_xxQp_ttRvzSQRzlF'
 func equalTuples<each Element: Equatable>(lhs: (repeat each Element), rhs: (repeat each Element)) -> Bool {

test/SILGen/synthesized_conformance_enum.swift

@@ -77,7 +77,7 @@ extension NoValues: Codable {}
 // Witness tables for Enum
 
 // CHECK-LABEL: sil_witness_table hidden <T where T : Equatable> Enum<T>: Equatable module synthesized_conformance_enum {
-// CHECK-NEXT:   method #Equatable."==": <Self where Self : Equatable> (Self.Type) -> (Self, Self) -> Bool : @$s28synthesized_conformance_enum4EnumOyxGSQAASQRzlSQ2eeoiySbx_xtFZTW	// protocol witness for static Equatable.== infix(_:_:) in conformance <A> Enum<A>
+// CHECK-NEXT:   method #Equatable."==": <Self where Self : Equatable, Self : ~Copyable> (Self.Type) -> (borrowing Self, borrowing Self) -> Bool : @$s28synthesized_conformance_enum4EnumOyxGSQAASQRzlSQ2eeoiySbx_xtFZTW	// protocol witness for static Equatable.== infix(_:_:) in conformance <A> Enum<A>
 // CHECK-NEXT:   conditional_conformance (T: Equatable): dependent
 // CHECK-NEXT: }