Get rid of all new***Array methods expect one.

This one is able to encode creation of array of any type and any dimension.
Note, it does not handle value classes.

Author: DarkDimius

src/dotty/runtime/Arrays.scala

@@ -26,42 +26,6 @@ object Arrays {
 
   /** Create an array of a reference type T.
    */
-  def newRefArray[T](componentType: Class[T])(length: Int): Array[T] =
-    jlr.Array.newInstance(componentType, length).asInstanceOf[Array[T]]
-
-  /** Create a Byte[] array */
-  def newByteArray(length: Int): Array[Byte] =
-    jlr.Array.newInstance(classOf[Byte], length).asInstanceOf[Array[Byte]]
-
-  /** Create a Short[] array */
-  def newShortArray(length: Int): Array[Short] =
-    jlr.Array.newInstance(classOf[Short], length).asInstanceOf[Array[Short]]
-
-  /** Create a Char[] array */
-  def newCharArray(length: Int): Array[Char] =
-    jlr.Array.newInstance(classOf[Char], length).asInstanceOf[Array[Char]]
-
-  /** Create an Int[] array */
-  def newIntArray(length: Int): Array[Int] =
-    jlr.Array.newInstance(classOf[Int], length).asInstanceOf[Array[Int]]
-
-  /** Create a Long[] array */
-  def newLongArray(length: Int): Array[Long] =
-    jlr.Array.newInstance(classOf[Long], length).asInstanceOf[Array[Long]]
-
-  /** Create a Float[] array */
-  def newFloatArray(length: Int): Array[Float] =
-    jlr.Array.newInstance(classOf[Float], length).asInstanceOf[Array[Float]]
-
-  /** Create a Double[] array */
-  def newDoubleArray(length: Int): Array[Double] =
-    jlr.Array.newInstance(classOf[Double], length).asInstanceOf[Array[Double]]
-
-  /** Create a Boolean[] array */
-  def newBooleanArray(length: Int): Array[Boolean] =
-    jlr.Array.newInstance(classOf[Boolean], length).asInstanceOf[Array[Boolean]]
-
-  /** Create a scala.runtime.BoxedUnit[] array */
-  def newUnitArray(length: Int): Array[Unit] =
-    jlr.Array.newInstance(classOf[scala.runtime.BoxedUnit], length).asInstanceOf[Array[Unit]]
+  def newArray[Arr](componentType: Class[_], returnType: Class[Arr], dimensions: Array[Int]): Arr =
+    jlr.Array.newInstance(componentType, dimensions: _*).asInstanceOf[Arr]
 }

src/dotty/tools/dotc/ast/tpd.scala

@@ -363,21 +363,21 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *  kind for the given element type in `typeArg`. No type arguments or
    *  `length` arguments are given.
    */
-  def newArray(typeArg: Tree, pos: Position)(implicit ctx: Context): Tree = {
-    val elemType = typeArg.tpe
-    val elemClass = elemType.classSymbol
-    def newArr(kind: String) =
-      ref(defn.DottyArraysModule).select(s"new${kind}Array".toTermName).withPos(pos)
-    if (TypeErasure.isUnboundedGeneric(elemType))
-      newArr("Generic").appliedToTypeTrees(typeArg :: Nil)
-    else if (elemClass.isPrimitiveValueClass)
-      newArr(elemClass.name.toString)
-    else {
-      val typeApplied = newArr("Ref").appliedToTypeTrees(typeArg :: Nil)
-      val classOfArg =
-        ref(defn.Predef_classOf).appliedToTypeTrees(typeArg :: Nil)
-      Apply(typeApplied, classOfArg :: Nil).withPos(typeArg.pos)
-    }
+  def newArray(elemTpe: Type, returnTpe: Type, pos: Position, dims: JavaSeqLiteral)(implicit ctx: Context): Tree = {
+    val elemClass = elemTpe.classSymbol
+    def newArr(symbol: TermSymbol) =
+      ref(defn.DottyArraysModule).select(symbol).withPos(pos)
+
+    if (!ctx.erasedTypes)
+      if (TypeErasure.isUnboundedGeneric(elemTpe)) {
+        //exists only before erasure
+        assert(dims.elems.tail.isEmpty)
+        newArr(defn.newGenericArrayMethod).appliedToType(elemTpe).appliedTo(dims.elems.head)
+      }
+      else
+        newArr(defn.newArrayMethod).appliedToTypeTrees(TypeTree(returnTpe) :: Nil).appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withPos(pos)
+    else  // after erasure
+      newArr(defn.newArrayMethod).appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withPos(pos)
   }
 
   // ------ Creating typed equivalents of trees that exist only in untyped form -------

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

@@ -246,6 +246,8 @@ class Definitions {
   def DottyPredefModule(implicit ctx: Context) = DottyPredefModuleRef.symbol
   lazy val DottyArraysModuleRef = ctx.requiredModuleRef("dotty.runtime.Arrays")
   def DottyArraysModule(implicit ctx: Context) = DottyArraysModuleRef.symbol
+    def newGenericArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newGenericArray")
+    def newArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newArray")
 
   lazy val NilModuleRef = ctx.requiredModuleRef("scala.collection.immutable.Nil")
   def NilModule(implicit ctx: Context) = NilModuleRef.symbol
@@ -277,6 +279,9 @@ class Definitions {
     def Array_clone(implicit ctx: Context) = Array_cloneR.symbol
     lazy val ArrayConstructorR            = ArrayClass.requiredMethodRef(nme.CONSTRUCTOR)
     def ArrayConstructor(implicit ctx: Context) = ArrayConstructorR.symbol
+  lazy val ArrayModuleType = ctx.requiredModuleRef("scala.Array")
+  def ArrayModule(implicit ctx: Context) = ArrayModuleType.symbol.moduleClass.asClass
+
 
   lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", BoxedUnitType, java.lang.Void.TYPE, UnitEnc)
   def UnitClass(implicit ctx: Context) = UnitType.symbol.asClass