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/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 {