Re-enable valueTypeNameToJavaType

Author: nicolasstucki

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

@@ -1047,7 +1047,7 @@ class Definitions {
 
 //  private val unboxedTypeRef = mutable.Map[TypeName, TypeRef]()
 //  private val javaTypeToValueTypeRef = mutable.Map[Class[_], TypeRef]()
-//  private val valueTypeNameToJavaType = mutable.Map[TypeName, Class[_]]()
+  private val valueTypeNamesToJavaType = mutable.Map[TypeName, Class[_]]()
 
   private def valueTypeRef(name: String, boxed: TypeRef, jtype: Class[_], enc: Int, tag: Name): TypeRef = {
     val vcls = ctx.requiredClassRef(name)
@@ -1056,7 +1056,7 @@ class Definitions {
     typeTags(vcls.name) = tag
 //    unboxedTypeRef(boxed.name) = vcls
 //    javaTypeToValueTypeRef(jtype) = vcls
-//    valueTypeNameToJavaType(vcls.name) = jtype
+    valueTypeNamesToJavaType(vcls.name) = jtype
     vcls
   }
 
@@ -1066,6 +1066,10 @@ class Definitions {
   /** The JVM tag for `tp` if it's a primitive, `java.lang.Object` otherwise. */
   def typeTag(tp: Type)(implicit ctx: Context): Name = typeTags(scalaClassName(tp))
 
+  /** The `Class[_]` of a primitive value type name */
+  def valueTypeNameToJavaType(name: TypeName)(implicit ctx: Context): Option[Class[_]] =
+    valueTypeNamesToJavaType.get(if (name.firstPart eq nme.scala_) name.lastPart.toTypeName else name)
+
   type PrimitiveClassEnc = Int
 
   val ByteEnc = 2

compiler/src/dotty/tools/dotc/interpreter/Interpreter.scala

@@ -110,16 +110,10 @@ class Interpreter(implicit ctx: Context) {
   /** List of classes of the parameters of the signature of `sym` */
   private def paramsSig(sym: Symbol): List[Class[_]] = {
     sym.signature.paramsSig.map { param =>
-      val paramString = param.toString
-      if (paramString == defn.BooleanClass.showFullName) classOf[Boolean]
-      else if (paramString == defn.ByteClass.showFullName) classOf[Byte]
-      else if (paramString == defn.CharClass.showFullName) classOf[Char]
-      else if (paramString == defn.ShortClass.showFullName) classOf[Short]
-      else if (paramString == defn.IntClass.showFullName) classOf[Int]
-      else if (paramString == defn.LongClass.showFullName) classOf[Long]
-      else if (paramString == defn.DoubleClass.showFullName) classOf[Float]
-      else if (paramString == defn.DoubleClass.showFullName) classOf[Double]
-      else classLoader.loadClass(paramString)
+      defn.valueTypeNameToJavaType(param) match {
+        case Some(clazz) => clazz
+        case None => classLoader.loadClass(param.toString)
+      }
     }
   }