Decouple handling array constructors from typer.

It's done in a separate ArrayConstructors phase now.

Author: DarkDimius

src/dotty/tools/dotc/Compiler.scala

@@ -63,7 +63,8 @@ class Compiler {
            new Getters,
            new ElimByName,
            new AugmentScala2Traits,
-           new ResolveSuper),
+           new ResolveSuper,
+           new ArrayConstructors),
       List(new Erasure),
       List(new ElimErasedValueType,
            new VCElideAllocations,

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

@@ -839,7 +839,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       case tpnme.Float => TYPE(defn.BoxedFloatModule)
       case tpnme.Double => TYPE(defn.BoxedDoubleModule)
       case tpnme.Unit => TYPE(defn.BoxedUnitModule)
-      case _ => Literal(Constant(TypeErasure.erasure(tp)))
+      case _ =>
+        if(ctx.erasedTypes || !tp.derivesFrom(defn.ArrayClass))
+          Literal(Constant(TypeErasure.erasure(tp)))
+        else Literal(Constant(tp))
     }
   }
 

src/dotty/tools/dotc/transform/ArrayConstructors.scala

@@ -0,0 +1,59 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import TreeTransforms._
+import Contexts.Context
+import Flags._
+import SymUtils._
+import Symbols._
+import SymDenotations._
+import Types._
+import Decorators._
+import DenotTransformers._
+import StdNames._
+import NameOps._
+import ast.Trees._
+import dotty.tools.dotc.ast.tpd
+import util.Positions._
+import Names._
+import collection.mutable
+import ResolveSuper._
+
+
+/** This phase rewrites calls to array constructors to newArray and newGenericArray methods
+  * in Dotty.runtime.Arrays module.
+  *
+  * Additionally it optimizes calls to scala.Array.ofDim functions
+  *
+  */
+class ArrayConstructors extends MiniPhaseTransform { thisTransform =>
+  import ast.tpd._
+
+  override def phaseName: String = "arrayConstructors"
+
+  override def transformApply(tree: tpd.Apply)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+    def rewrite(elemType: Type, dims: List[Tree]) =
+      tpd.newArray(elemType, tree.tpe, tree.pos, JavaSeqLiteral(dims, TypeTree(defn.IntClass.typeRef)).asInstanceOf[JavaSeqLiteral])
+
+    if (tree.fun.symbol eq defn.ArrayConstructor) {
+      tree.fun match {
+        case TypeApply(tycon, targ :: Nil)  =>
+          rewrite(targ.tpe, tree.args)
+        case _ =>
+          ???
+      }
+    } else if ((tree.fun.symbol.maybeOwner eq defn.ArrayModule) && (tree.fun.symbol.name eq nme.ofDim) && !tree.tpe.isInstanceOf[MethodicType]) {
+
+      tree.fun match {
+        case Apply(TypeApply(t: Ident, targ), dims) =>
+          rewrite(targ.head.tpe, dims)
+        case Apply(TypeApply(t: Select, targ), dims) =>
+          Block(t.qualifier :: Nil, rewrite(targ.head.tpe, dims))
+        case _ => tree
+      }
+
+    } else tree
+  }
+}
+

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

@@ -556,7 +556,7 @@ trait Applications extends Compatibility { self: Typer =>
                 if (proto.argsAreTyped) new ApplyToTyped(tree, fun1, funRef, proto.typedArgs, pt)
                 else new ApplyToUntyped(tree, fun1, funRef, proto, pt)(argCtx)
               val result = app.result
-              convertNewArray(ConstFold(result))
+              ConstFold(result)
             } { (failedVal, failedState) =>
               val fun2 = tryInsertImplicitOnQualifier(fun1, proto)
               if (fun1 eq fun2) {
@@ -632,15 +632,6 @@ trait Applications extends Compatibility { self: Typer =>
   def adaptTypeArg(tree: tpd.Tree, bound: Type)(implicit ctx: Context): tpd.Tree =
     tree.withType(tree.tpe.etaExpandIfHK(bound))
 
-  /** Rewrite `new Array[T](....)` trees to calls of newXYZArray methods. */
-  def convertNewArray(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
-    case Apply(TypeApply(tycon, targ :: Nil), args) if tycon.symbol == defn.ArrayConstructor =>
-      fullyDefinedType(tree.tpe, "array", tree.pos)
-      tpd.cpy.Apply(tree)(newArray(targ, tree.pos), args)
-    case _ =>
-      tree
-  }
-
   def typedUnApply(tree: untpd.Apply, selType: Type)(implicit ctx: Context): Tree = track("typedUnApply") {
     val Apply(qual, args) = tree
 

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

@@ -1671,8 +1671,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
               case _ => Nil
             }
             if (typeArgs.isEmpty) typeArgs = constrained(poly, tree)._2
-            convertNewArray(
-              adaptInterpolated(tree.appliedToTypes(typeArgs), pt, original))
+              adaptInterpolated(tree.appliedToTypes(typeArgs), pt, original)
           }
         case wtp =>
           pt match {