Changes in array creation scheme

src/dotty/runtime/Arrays.scala

@@ -0,0 +1,17 @@
+package dotty.runtime
+
+import scala.reflect.ClassTag
+
+object Arrays {
+  def newGenericArray[T](length: Int)(implicit tag: ClassTag[T]): Array[T] = tag.newArray(length)
+  def newRefArray[T](length: Int): Array[T] = ???
+  def newByteArray(length: Int): Array[Byte] = ???
+  def newShortArray(length: Int): Array[Short] = ???
+  def newCharArray(length: Int): Array[Char] = ???
+  def newIntArray(length: Int): Array[Int] = ???
+  def newLongArray(length: Int): Array[Long] = ???
+  def newFloatArray(length: Int): Array[Float] = ???
+  def newDoubleArray(length: Int): Array[Double] = ???
+  def newBooleanArray(length: Int): Array[Boolean] = ???
+  def newUnitArray(length: Int): Array[Unit] = ???
+}

src/dotty/tools/dotc/TypeErasure.scala

@@ -153,10 +153,24 @@ object TypeErasure {
     }
   }
 
-  def isUnboundedGeneric(tp: Type)(implicit ctx: Context) = !(
-    (tp derivesFrom defn.ObjectClass) ||
-    tp.classSymbol.isPrimitiveValueClass ||
-    (tp.typeSymbol is JavaDefined))
+  /** Is `tp` an abstract type or polymorphic type parameter that has `Any`
+   *  as upper bound and that is not Java defined? Arrays of such types are
+   *  erased to `Object` instead of `ObjectArray`.
+   */
+  def isUnboundedGeneric(tp: Type)(implicit ctx: Context): Boolean = tp match {
+    case tp: TypeRef =>
+      tp.symbol.isAbstractType &&
+      !tp.derivesFrom(defn.ObjectClass) &&
+      !tp.typeSymbol.is(JavaDefined)
+    case tp: PolyParam =>
+      !tp.derivesFrom(defn.ObjectClass) &&
+      !tp.binder.resultType.isInstanceOf[JavaMethodType]
+    case tp: TypeProxy => isUnboundedGeneric(tp.underlying)
+    case tp: AndType => isUnboundedGeneric(tp.tp1) || isUnboundedGeneric(tp.tp2)
+    case tp: OrType => isUnboundedGeneric(tp.tp1) && isUnboundedGeneric(tp.tp2)
+    case _ => false
+  }
+
 
   /** The erased least upper bound is computed as follows
    *  - if both argument are arrays, an array of the lub of the element types

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

@@ -298,6 +298,19 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     case ConstantType(value) => Literal(value)
   }
 
+  /** A tree representing a `newXYZArray` operation of the right
+   *  kind for the given element type. No type arguments or
+   *  `length` arguments are given.
+   */
+  def newArray(elemType: Type)(implicit ctx: Context) = {
+    val elemClass = elemType.classSymbol
+    val kind =
+      if (TypeErasure.isUnboundedGeneric(elemType)) "Generic"
+      else if (elemClass.isPrimitiveValueClass) elemClass.name.toString
+      else "Ref"
+    ref(defn.DottyArraysModule).select(s"new${kind}Array".toTermName)
+  }
+
   // ------ Creating typed equivalents of trees that exist only in untyped form -------
 
   /** new C(args), calling the primary constructor of C */
@@ -678,7 +691,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Throw(New(defn.ClassCastExceptionClass.typeRef, Nil)) withPos tree.pos
     }
   }
-  
+
   def applyOverloaded(receiver: Tree, method: TermName, args: List[Tree], targs: List[Type], expectedType: Type, isAnnotConstructor: Boolean = false)(implicit ctx: Context): Tree = {
     val typer = ctx.typer
     val proto = new FunProtoTyped(args, expectedType, typer)

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

@@ -120,7 +120,7 @@ object Contexts {
     protected def scope_=(scope: Scope) = _scope = scope
     def scope: Scope = _scope
 
-    /** The current type assigner ot typer */
+    /** The current type assigner or typer */
     private[this] var _typeAssigner: TypeAssigner = _
     protected def typeAssigner_=(typeAssigner: TypeAssigner) = _typeAssigner = typeAssigner
     def typeAssigner: TypeAssigner = _typeAssigner

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

@@ -193,6 +193,7 @@ class Definitions {
     def staticsMethod(name: PreName) = ctx.requiredMethod(ScalaStaticsClass, name)
 
   lazy val DottyPredefModule = ctx.requiredModule("dotty.DottyPredef")
+  lazy val DottyArraysModule = ctx.requiredModule("dotty.runtime.Arrays")
   lazy val NilModule = ctx.requiredModule("scala.collection.immutable.Nil")
   lazy val PredefConformsClass = ctx.requiredClass("scala.Predef." + tpnme.Conforms)
 
@@ -211,6 +212,7 @@ class Definitions {
     lazy val Array_update                = ctx.requiredMethod(ArrayClass, nme.update)
     lazy val Array_length                = ctx.requiredMethod(ArrayClass, nme.length)
     lazy val Array_clone                 = ctx.requiredMethod(ArrayClass, nme.clone_)
+    lazy val ArrayConstructor            = ctx.requiredMethod(ArrayClass, nme.CONSTRUCTOR)
   lazy val traversableDropMethod  = ctx.requiredMethod(ScalaRuntimeClass, nme.drop)
   lazy val uncheckedStableClass: ClassSymbol = ctx.requiredClass("scala.annotation.unchecked.uncheckedStable")
 

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

@@ -204,7 +204,6 @@ object NameOps {
       case nme.length => nme.primitive.arrayLength
       case nme.update => nme.primitive.arrayUpdate
       case nme.clone_ => nme.clone_
-      case nme.CONSTRUCTOR => nme.primitive.arrayConstructor
     }
 
     /** If name length exceeds allowable limit, replace part of it by hash */

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

@@ -433,7 +433,6 @@ object StdNames {
     val moduleClass : N         = "moduleClass"
     val name: N                 = "name"
     val ne: N                   = "ne"
-    val newArray: N             = "newArray"
     val newFreeTerm: N          = "newFreeTerm"
     val newFreeType: N          = "newFreeType"
     val newNestedSymbol: N      = "newNestedSymbol"
@@ -691,8 +690,7 @@ object StdNames {
       val arrayApply: TermName  = "[]apply"
       val arrayUpdate: TermName = "[]update"
       val arrayLength: TermName = "[]length"
-      val arrayConstructor: TermName = "[]<init>"
-      val names: Set[Name] = Set(arrayApply, arrayUpdate, arrayLength, arrayConstructor)
+      val names: Set[Name] = Set(arrayApply, arrayUpdate, arrayLength)
     }
 
     def isPrimitiveName(name: Name) = primitive.names.contains(name)

src/dotty/tools/dotc/typer/Applications.scala

@@ -596,7 +596,16 @@ trait Applications extends Compatibility { self: Typer =>
         checkBounds(typedArgs, pt)
       case _ =>
     }
-    assignType(cpy.TypeApply(tree)(typedFn, typedArgs), typedFn, typedArgs)
+    val res = assignType(cpy.TypeApply(tree)(typedFn, typedArgs), typedFn, typedArgs)
+    if (res.symbol == defn.ArrayConstructor) {
+      val defn.ArrayType(elemType) = res.tpe.widen.resultType
+      val newArr = tpd.newArray(elemType).withPos(tree.pos)
+      newArr.tpe.widen match {
+        case _: PolyType => newArr.appliedToTypeTrees(typedArgs)
+        case _ => newArr
+      }
+    }
+    else res
   }
 
   def typedUnApply(tree: untpd.Apply, selType: Type)(implicit ctx: Context): Tree = track("typedUnApply") {

tests/pos/new-array.scala

@@ -0,0 +1,7 @@
+object Test {
+  val w = new Array[String](10)
+  val x = new Array[Int](10)
+  def f[T: reflect.ClassTag] = new Array[T](10)
+  val y = new Array[Any](10)
+  val z = new Array[Unit](10)
+}