refactor, fix caseClassHash test

Static.mix(acc, this.productPrefix.hashCode()) in synthetic case class hash code updated to add parens.

Author: bishabosha

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -357,6 +357,7 @@ class Definitions {
   @tu lazy val ScalaRuntimeModule: Symbol = ctx.requiredModule("scala.runtime.ScalaRunTime")
     def runtimeMethodRef(name: PreName): TermRef = ScalaRuntimeModule.requiredMethodRef(name)
     def ScalaRuntime_drop: Symbol = runtimeMethodRef(nme.drop).symbol
+    @tu lazy val ScalaRuntime__hashCode: Symbol = runtimeMethodRef("_hashCode").symbol
 
   @tu lazy val BoxesRunTimeModule: Symbol = ctx.requiredModule("scala.runtime.BoxesRunTime")
   @tu lazy val ScalaStaticsModule: Symbol = ctx.requiredModule("scala.runtime.Statics")

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -141,7 +141,7 @@ object StdNames {
     val INITIALIZER_PREFIX: N         = "initial$"
     val BOUNDTYPE_ANNOT: N            = "$boundType$"
     val QUOTE: N                      = "'"
-    val TYPE_QUOTE: N                = "type_'"
+    val TYPE_QUOTE: N                 = "type_'"
     val TRAIT_SETTER_SEPARATOR: N     = str.TRAIT_SETTER_SEPARATOR
 
     // value types (and AnyRef) are all used as terms as well
@@ -368,6 +368,7 @@ object StdNames {
     val TypeRef: N              = "TypeRef"
     val UNIT : N                = "UNIT"
     val add_ : N                = "add"
+    val acc: N                  = "acc"
     val annotation: N           = "annotation"
     val anyHash: N              = "anyHash"
     val anyValClass: N          = "anyValClass"

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

@@ -238,7 +238,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
      *  gets the `hashCode` method:
      *
      *  ```
-     *  "C".hashCode // constant folded
+     *  def hashCode: Int = "C".hashCode // constant folded
      *  ```
      *
      *  The class
@@ -247,7 +247,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
      *  case class C(x: T, y: U)
      *  ```
      *
-     *  if non of `T` or `U` are primitive types, gets the `hashCode` method:
+     *  if none of `T` or `U` are primitive types, gets the `hashCode` method:
      *
      *  ```
      *  def hashCode: Int = ScalaRunTime._hashCode(this)
@@ -256,12 +256,12 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
      *  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
+      if (clazz.is(ModuleClass))
         Literal(Constant(clazz.name.stripModuleClassSuffix.toString.hashCode))
-      else if accessors `exists` (_.info.finalResultType.classSymbol.isPrimitiveValueClass) then
+      else if (accessors `exists` (_.info.finalResultType.classSymbol.isPrimitiveValueClass))
         caseHashCodeBody
       else
-        ref(defn.ScalaRuntimeModule).select("_hashCode".toTermName).appliedTo(This(clazz))
+        ref(defn.ScalaRuntimeModule).select(defn.ScalaRuntime__hashCode).appliedTo(This(clazz))
     }
 
     /** The class
@@ -275,19 +275,19 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
      *  ```
      *  def hashCode: Int = {
      *    <synthetic> var acc: Int = 0xcafebabe
-     *    acc = Statics.mix(acc, this.productPrefix.hashCode);
+     *    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 acc       = ctx.newSymbol(ctx.owner, "acc".toTermName, Mutable | Synthetic, defn.IntType, coord = ctx.owner.span)
-      val accDef    = ValDef(acc, Literal(Constant(0xcafebabe)))
+      val acc = ctx.newSymbol(ctx.owner, nme.acc, 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
+        ref(defn.staticsMethod("mix")).appliedTo(ref(acc), This(clazz).select(defn.Product_productPrefix).select(defn.Any_hashCode).appliedToNone))
+      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)

tests/run/caseClassHash.check

@@ -1,9 +1,9 @@
 Foo(true,-1,-1,d,-5,-10,500.0,500.0,List(),5.0)
 Foo(true,-1,-1,d,-5,-10,500.0,500.0,List(),5)
-205963949
-205963949
+930449446
+930449446
 true
-## method 1: 205963949
-## method 2: 205963949
-   Murmur 1: 1383698062
-   Murmur 2: 1383698062
+## method 1: 930449446
+## method 2: 930449446
+   Murmur 1: 930449446
+   Murmur 2: 930449446