[SR-5819] Suggest as? AnyHashable when as? Equatable or as? Hashable is attempted

[jckarter]

Previous ID	SR-5819
Radar	None
Original Reporter	@jckarter
Type	Bug

Additional Detail from JIRA

Votes	0
Component/s	Compiler
Labels	Bug, DiagnosticsQoI, StarterBug
Assignee	None
Priority	Medium

md5: 5e4ffb6d40f711123adf86651f9a3a8f

Issue Description:

If you have two values of type Any or otherwise opaque type and you want to test whether they're equal, it's natural to try to write something like:

if let a = a as? Equatable, b = b as? Equatable {
  return a == b
}

Maybe someday that will work, but in the meantime dynamically casting to AnyHashable can get the desired effect. It'd be nice QoI to have a diagnostic telling people they can do this when they try similar things that don't.

[swift-ci]

Comment by Kevin Lundberg (JIRA)

I'm taking a stab at this, and I'm wondering if it's enough to just check any place where someone tries to do `blah as? Equatable`, or should this fix-it only apply inside conditional statements? Should it also apply for `as`/`as!`, and in a case like this? `let x: Equatable = "X"`

[belkadan]

I'd rather not recommend casting to AnyHashable, which has subtleties of its own. Wouldn't a protocol shared by all your Equatable objects be a better idiom?

[jckarter]

The subtleties should be transparent to most people, they only affect bridged ObjC types. If you have a protocol shared by all your Equatable objects, that protocol still can't refine Equatable without losing support for the existential type, and if it doesn't refine Equatable, you'll need to cast to AnyHashable to invoke ==.

[belkadan]

The protocol doesn't have to look like Equatable to have the operation:

protocol InterestingType {
  func same(as other: InterestingType) // option 1
  func same<Other: InterestingType>(as other: Other) // option 2
}

But if all implementations of this are going to start with a type-check, maybe it doesn't matter.

[swift-ci]

Comment by Suyash Shekhar (JIRA)

Are there any updates or decision for this bug?

[jckarter]

We haven't discussed this specifically recently. I still think this is a good idea, I don't know how @belkadan feels.

[belkadan]

I still don't think it's a good idea, but I don't feel super strongly about it.

[jameesbrown]

Hi @jckarter, I was looking at this and I think there is a decent solution now without AnyHashable:

extension Equatable {
  func isEqualTo(_ other: Any) -> Bool {
    guard case let other as Self = other else {
      return false
    }
    return self == other
  }
}

let a = 1 as Any
let b = 2 as Any
if let areEqual = (a as? any Equatable)?.isEqualTo(b) {
  return areEqual 
}

Something else is that the following would not work (as intended) with AnyHashable:

struct S: Equatable {
  var x: Int
}
let a = S(x: 0) as Any
let b = S(x: 10) as Any
if let a = a as? AnyHashable, let b = b as? AnyHashable {
  return a == b
}

It is not as convenient of course; it depends on the user defining the above extension or similar. An alternative could be an AnyEquatable type so that it can be written the same way as you have with AnyHashable.