Better fix for $569

We now provide a ndew symbol for the `newRefArray` definition, which makes
any further treatment after erasure unnecessary.

Author: odersky

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

@@ -469,20 +469,26 @@ object Erasure extends TypeTestsCasts{
         tpt = untpd.TypedSplice(TypeTree(sym.info).withPos(vdef.tpt.pos))), sym)
 
     override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = {
-      val restpe =
-        if (sym == defn.newRefArrayMethod) defn.ObjectType
-          // newRefArray is the only source defined method that's polymorphic
-          // after erasure; needs to be treated specially
-        else sym.info.resultType
+      var effectiveSym = sym
+      if (sym == defn.newRefArrayMethod) {
+        // newRefArray is treated specially: It's new only method source-defined method
+        // that has a polymorphic type after erasure. But treating its (dummy) definition
+        // with a polymorphic type at and after erasure is an awkward special case.
+        // We therefore rewrite the method definition with a new Symbol of type
+        // (length: Int)Object
+        val MethodType(pnames, ptypes) = sym.info.resultType
+        effectiveSym = sym.copy(info = MethodType(pnames, ptypes, defn.ObjectType))
+      }
+      val restpe = effectiveSym.info.resultType
       val ddef1 = untpd.cpy.DefDef(ddef)(
         tparams = Nil,
-        vparamss = (outer.paramDefs(sym) ::: ddef.vparamss.flatten) :: Nil,
+        vparamss = (outer.paramDefs(effectiveSym) ::: ddef.vparamss.flatten) :: Nil,
         tpt = untpd.TypedSplice(TypeTree(restpe).withPos(ddef.tpt.pos)),
         rhs = ddef.rhs match {
           case id @ Ident(nme.WILDCARD) => untpd.TypedSplice(id.withType(restpe))
           case _ => ddef.rhs
         })
-      super.typedDefDef(ddef1, sym)
+      super.typedDefDef(ddef1, effectiveSym)
     }
 
     /** After erasure, we may have to replace the closure method by a bridge.