case class hashCode implementation matches 2.13

Author: bishabosha

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -119,7 +119,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
 
       def syntheticRHS(vrefss: List[List[Tree]])(implicit ctx: Context): Tree = synthetic.name match {
         case nme.hashCode_ if isDerivedValueClass(clazz) => valueHashCodeBody
-        case nme.hashCode_ => caseHashCodeBody
+        case nme.hashCode_ => chooseHashcode
         case nme.toString_ => if (clazz.is(ModuleClass)) ownName else forwardToRuntime(vrefss.head)
         case nme.equals_ => equalsBody(vrefss.head.head)
         case nme.canEqual_ => canEqualBody(vrefss.head.head)
@@ -232,35 +232,65 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     /** The class
      *
      *  ```
-     *  package p
-     *  case class C(x: T, y: T)
+     *  case object C
+     *  ```
+     *
+     *  gets the `hashCode` method:
+     *
+     *  ```
+     *  "C".hashCode // constant folded
+     *  ```
+     *
+     *  The class
+     *
+     *  ```
+     *  case class C(x: T, y: U)
+     *  ```
+     *
+     *  if non of `T` or `U` are primitive types, gets the `hashCode` method:
+     *
+     *  ```
+     *  def hashCode: Int = ScalaRunTime._hashCode(this)
+     *  ```
+     *
+     *  else if either `T` or `U` are primitive, gets the `hashCode` method implemented by [[caseHashCodeBody]]
+     */
+    def chooseHashcode(implicit ctx: Context) = {
+      if clazz.is(ModuleClass) then
+        Literal(Constant(clazz.name.stripModuleClassSuffix.toString.hashCode))
+      else if accessors `exists` (_.info.finalResultType.classSymbol.isPrimitiveValueClass) then
+        caseHashCodeBody
+      else
+        ref(defn.ScalaRuntimeModule).select("_hashCode".toTermName).appliedTo(This(clazz))
+    }
+
+    /** The class
+     *
+     *  ```
+     *  case class C(x: Int, y: T)
      *  ```
      *
      *  gets the `hashCode` method:
      *
      *  ```
      *  def hashCode: Int = {
-     *    <synthetic> var acc: Int = "p.C".hashCode // constant folded
+     *    <synthetic> var acc: Int = 0xcafebabe
+     *    acc = Statics.mix(acc, this.productPrefix.hashCode);
      *    acc = Statics.mix(acc, x);
      *    acc = Statics.mix(acc, Statics.this.anyHash(y));
      *    Statics.finalizeHash(acc, 2)
      *  }
      *  ```
      */
     def caseHashCodeBody(implicit ctx: Context): Tree = {
-      val seed = clazz.fullName.toString.hashCode
-      if (accessors.nonEmpty) {
-        val acc = ctx.newSymbol(ctx.owner, "acc".toTermName, Mutable | Synthetic, defn.IntType, coord = ctx.owner.span)
-        val accDef = ValDef(acc, Literal(Constant(seed)))
-        val mixes = for (accessor <- accessors) yield
-          Assign(ref(acc), ref(defn.staticsMethod("mix")).appliedTo(ref(acc), hashImpl(accessor)))
-        val finish = ref(defn.staticsMethod("finalizeHash")).appliedTo(ref(acc), Literal(Constant(accessors.size)))
-        Block(accDef :: mixes, finish)
-      } else {
-        // Pre-compute the hash code
-        val hash = scala.runtime.Statics.finalizeHash(seed, 0)
-        Literal(Constant(hash))
-      }
+      val acc       = ctx.newSymbol(ctx.owner, "acc".toTermName, Mutable | Synthetic, defn.IntType, coord = ctx.owner.span)
+      val accDef    = ValDef(acc, Literal(Constant(0xcafebabe)))
+      val mixPrefix = Assign(ref(acc),
+        ref(defn.staticsMethod("mix")).appliedTo(ref(acc), This(clazz).select(defn.Product_productPrefix).select(defn.Any_hashCode)))
+      val mixes   = for accessor <- accessors yield
+        Assign(ref(acc), ref(defn.staticsMethod("mix")).appliedTo(ref(acc), hashImpl(accessor)))
+      val finish = ref(defn.staticsMethod("finalizeHash")).appliedTo(ref(acc), Literal(Constant(accessors.size)))
+      Block(accDef :: mixPrefix :: mixes, finish)
     }
 
     /** The `hashCode` implementation for given symbol `sym`. */