Merge pull request #5110 from sjrd/remove-duplicate-implem-of-hashcodes

Remove the duplicate implem of hash codes for numbers.

4 files changed, 19 insertions, 21 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
index fe08c4355d..22587c68f7 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
@@ -1089,7 +1089,6 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
 
     /* Generate the scala ## method. */
     def genScalaHash(tree: Tree, applyPos: Position): BType = {
-      genLoadModule(ScalaRunTimeModule) // TODO why load ScalaRunTimeModule if ## has InvokeStyle of Static(false) ?
       genLoad(tree, ObjectRef)
       genCallMethod(hashMethodSym, InvokeStyle.Static, applyPos)
     }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
index 4d03f9851e..0b53ea2fb1 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
@@ -251,7 +251,7 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: Global]](val bTypes: BTFS) {
     )
   }
 
-  lazy val hashMethodSym: Symbol = getMember(ScalaRunTimeModule, nme.hash_)
+  lazy val hashMethodSym: Symbol = getMember(RuntimeStaticsModule, nme.anyHash)
 
   // TODO @lry avoiding going through through missingHook for every line in the REPL: https://github.com/scala/scala/commit/8d962ed4ddd310cc784121c426a2e3f56a112540
   lazy val AndroidParcelableInterface : Symbol = getClassIfDefined("android.os.Parcelable")
diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala
index ac794201a4..0301e06c87 100644
--- a/src/compiler/scala/tools/nsc/transform/Erasure.scala
+++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala
@@ -1013,24 +1013,20 @@ abstract class Erasure extends AddInterfaces
                 // erasure the ScalaRunTime.hash overload goes from Unit => Int to BoxedUnit => Int.
                 // This must be because some earlier transformation is being skipped on ##, but so
                 // far I don't know what.  For null we now define null.## == 0.
+                def staticsCall(methodName: TermName): Tree = {
+                  val newTree = gen.mkMethodCall(RuntimeStaticsModule, methodName, qual :: Nil)
+                  global.typer.typed(newTree)
+                }
+
                 qual.tpe.typeSymbol match {
                   case UnitClass | NullClass                    => LIT(0)
                   case IntClass                                 => qual
                   case s @ (ShortClass | ByteClass | CharClass) => numericConversion(qual, s)
                   case BooleanClass                             => If(qual, LIT(true.##), LIT(false.##))
-                  case _                                        =>
-                    // Since we are past typer, we need to avoid creating trees carrying
-                    // overloaded types.  This logic is custom (and technically incomplete,
-                    // although serviceable) for def hash.  What is really needed is for
-                    // the overloading logic presently hidden away in a few different
-                    // places to be properly exposed so we can just call "resolveOverload"
-                    // after typer.  Until then:
-                    val alts    = ScalaRunTimeModule.info.member(nme.hash_).alternatives
-                    def alt1    = alts find (_.info.paramTypes.head =:= qual.tpe)
-                    def alt2    = ScalaRunTimeModule.info.member(nme.hash_) suchThat (_.info.paramTypes.head.typeSymbol == AnyClass)
-                    val newTree = gen.mkRuntimeCall(nme.hash_, qual :: Nil) setSymbol (alt1 getOrElse alt2)
-
-                    global.typer.typed(newTree)
+                  case LongClass                                => staticsCall(nme.longHash)
+                  case FloatClass                               => staticsCall(nme.floatHash)
+                  case DoubleClass                              => staticsCall(nme.doubleHash)
+                  case _                                        => staticsCall(nme.anyHash)
                 }
               } else if (isPrimitiveValueClass(qual.tpe.typeSymbol)) {
                 // Rewrite 5.getClass to ScalaRunTime.anyValClass(5)
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index 243a706745..6d883aee3d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -93,11 +93,14 @@ trait SyntheticMethods extends ast.TreeDSL {
     def forwardToRuntime(method: Symbol): Tree =
       forwardMethod(method, getMember(ScalaRunTimeModule, (method.name prepend "_")))(mkThis :: _)
 
-    def callStaticsMethod(name: String)(args: Tree*): Tree = {
-      val method = termMember(RuntimeStaticsModule, name)
+    def callStaticsMethodName(name: TermName)(args: Tree*): Tree = {
+      val method = RuntimeStaticsModule.info.member(name)
       Apply(gen.mkAttributedRef(method), args.toList)
     }
 
+    def callStaticsMethod(name: String)(args: Tree*): Tree =
+      callStaticsMethodName(newTermName(name))(args: _*)
+
     // Any concrete member, including private
     def hasConcreteImpl(name: Name) =
       clazz.info.member(name).alternatives exists (m => !m.isDeferred)
@@ -245,10 +248,10 @@ trait SyntheticMethods extends ast.TreeDSL {
         case BooleanClass                       => If(Ident(sym), Literal(Constant(1231)), Literal(Constant(1237)))
         case IntClass                           => Ident(sym)
         case ShortClass | ByteClass | CharClass => Select(Ident(sym), nme.toInt)
-        case LongClass                          => callStaticsMethod("longHash")(Ident(sym))
-        case DoubleClass                        => callStaticsMethod("doubleHash")(Ident(sym))
-        case FloatClass                         => callStaticsMethod("floatHash")(Ident(sym))
-        case _                                  => callStaticsMethod("anyHash")(Ident(sym))
+        case LongClass                          => callStaticsMethodName(nme.longHash)(Ident(sym))
+        case DoubleClass                        => callStaticsMethodName(nme.doubleHash)(Ident(sym))
+        case FloatClass                         => callStaticsMethodName(nme.floatHash)(Ident(sym))
+        case _                                  => callStaticsMethodName(nme.anyHash)(Ident(sym))
       }
     }