Case class hashing

[ctongfei]

Currently the hashing of case classes are synthesized, and their implementation is the same as scala.util.hashing.MurmurHash3.productHash.
This function takes into account the productPrefix only when the productArity is 0.

This produces the following problem:

scala> Left(1).##
res1: Int = 818387364

scala> Right(1).##
res2: Int = 818387364

Should productPrefix always be mixed into the hashCode by using productPrefix.## as the seed?

Implementation of scala.util.hashing.MurmurHash3.productHash:

  /** Compute the hash of a product */
  final def productHash(x: Product, seed: Int): Int = {
    val arr = x.productArity
    // Case objects have the hashCode inlined directly into the
    // synthetic hashCode method, but this method should still give
    // a correct result if passed a case object.
    if (arr == 0) {
      x.productPrefix.hashCode
    }
    else {
      var h = seed // !!! I propose change this to "var h = x.productPrefix.hashCode"
      var i = 0
      while (i < arr) {
        h = mix(h, x.productElement(i).##)
        i += 1
      }
      finalizeHash(h, arr)
    }
  }

Related discussions on the Scala contributors site: https://contributors.scala-lang.org/t/case-class-hashing/1076

[Ichoran]

This isn't the way to fix the issue, though, as it prevents you from ignoring productPrefix if it's irrelevant to you. Case classes should by default call productHash(this, productPrefix.hashCode).

One could add another productHash method that doesn't take a seed that does that by default.

[lrytz]

We should probably still use the productSeed to start off, to prevent product hashes from clashing with other hashes.

[lrytz]

@Ichoran

• Can you elaborate why you'd like to have the option for users of MurmurHash3.productHash to ignore the prefix?
• I feel like productHash(myCaseClassInstance, productSeed) should give the same result as myCaseClassInstance.## (which is generated in the compiler if the case class has primitive params, so it doesn't always call into productHash). This means that the implementation of productHash would have to include the prefix.
• So for the option to ignore the prefix, could we add a ignorePrefix boolean parameter with default to that method?

[lrytz]

WIP: https://github.com/scala/scala/compare/2.13.x...lrytz:t10495?expand=1

[Ichoran]

@lrytz - Two reasons:

1. It might be very important that two case classes to not have the same product prefix hash code, which isn't guaranteed (but is if you use the seed manually), and
2. Why look up an extra hash code when there's nothing else in your map and it doesn't matter? (Which I imagine is a very common use case.)

Anyway, I was objecting to changing the productHash method itself. It's okay if the default case class one changes to better distinguish different wrappers around the same values. I think it's important for the default to match what the compiler generates.

[lrytz]

I maybe didn't follow all your comments, but it sounds like my WIP would conform to your requirements. If not, could you post notes on the commit? lrytz/scala@4ee2713

[lrytz]

^ ping @Ichoran