[SR-12092] AnyHashable instances with unrelated base types compare equal

[NevinBR]

Previous ID	SR-12092
Radar	rdar://problem/58999133
Original Reporter	@NevinBR
Type	Bug
Status	Resolved
Resolution	Done

Environment

• Swift 5.1.3 (swiftlang-1100.0.282.1 clang-1100.0.33.15)
• MacOS 10.14.6 (18G103)

I observe the same results in both:
• Xcode 11.3.1 playground for MacOS
• Swift REPL in Terminal

Additional Detail from JIRA

Votes	0
Component/s	Standard Library
Labels	Bug
Assignee	None
Priority	Medium

md5: 977913cfdf8c4746de5a59c4a30a3555

Issue Description:

When values representing the same integer are stored as different types (whether integer or floating-point) then wrapped in AnyHashable, the resulting AnyHashable instances compare equal even though the underlying base types are different:

let a = AnyHashable(1)
let b = AnyHashable(1.0)
let c = AnyHashable(1 as UInt8)
(a == b, a == c, b == c)    // (true, true, true)
type(of: a.base) == type(of: b.base)  // false
type(of: a.base) == type(of: c.base)  // false
type(of: b.base) == type(of: c.base)  // false

[xwu]

As mentioned in the companion forum thread, this is the intended behavior. It is implemented [here| https://github.com/apple/swift/blob/3ec5e76ee30b2b50d26c455736ff108515b9ada8/stdlib/public/core/FloatingPointTypes.swift.gyb#L1189] for floating point types and [here| https://github.com/apple/swift/blob/da61cc8cdf7aa2bfb3ab03200c52c4d371dc6751/stdlib/public/core/IntegerTypes.swift.gyb#L1778] for integers, and for the rationale given in those comments.

[NevinBR]

The documentation for AnyHashable states:

Two instances of `AnyHashable` compare as equal if and only if the underlying types have the same conformance to the `Equatable` protocol and the underlying values compare as equal.

This strongly implies that two instances of AnyHashable will compare as equal if and only if the underlying instances compare equal with the same == operator satisfying the Equatable protocol.

However attempting to directly compare an Int with a Double raises a compiler error as expected, because those types do not share a conformance to Equatable

(1 as Int) == (1 as Double)      // error

[xwu]

As I mentioned on the forum, the documentation is out of date. See: https://bugs.swift.org/browse/SR-7496

[beccadax]

@swift-ci create

[lorentey]

Xiaodi has a PR up: #29498

[lorentey]

Merged (bbd888f) – thanks @xwu!

[NevinBR]

The updated documentation is still not quite right:

/// Where conversion using `as` or `as?` is possible between two types (such as
/// `Int` and `NSNumber`), `AnyHashable` uses a canonical representation of the
/// type-erased value so that instances wrapping the same value of either type
/// compare as equal. For example, `AnyHashable(42)` compares as equal to
/// `AnyHashable(42 as NSNumber)`.

This would imply that a String and a String? storing the same value would be equal as AnyHashable (because String can be as-cast to String?), but in fact they are not:

let a = "test"
let b = a as Optional
AnyHashable(a) == AnyHashable(b)
// false

[xwu]

This does imply that it should be the case; that's not the fault of the documentation. That they are not comparing as equal is a bug in the implementation, which is SR-9047. @lorentey has created a potential fix as PR #20523.