Workaround scala#592 Insert casts all over the place in specialised methods.

The way this fix is structured ensures that if scala#592 ever gets fixed, no casts will be inserted.

Author: DarkDimius

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

@@ -31,7 +31,7 @@ import dotty.tools.dotc.transform.SymUtils._
  *  gets two different denotations in the same period. Hence, if -Yno-double-bindings is
  *  set, we would get a data race assertion error.
  */
-final class TreeTypeMap(
+class TreeTypeMap(
   val typeMap: Type => Type = IdentityTypeMap,
   val treeMap: tpd.Tree => tpd.Tree = identity _,
   val oldOwners: List[Symbol] = Nil,
@@ -60,7 +60,7 @@ final class TreeTypeMap(
 
   def mapType(tp: Type) =
     mapOwnerThis(typeMap(tp).substSym(substFrom, substTo))
-  
+
   private def updateDecls(prevStats: List[Tree], newStats: List[Tree]): Unit =
     if (prevStats.isEmpty) assert(newStats.isEmpty)
     else {
@@ -75,7 +75,7 @@ final class TreeTypeMap(
       updateDecls(prevStats.tail, newStats.tail)
     }
 
-  override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = treeMap(tree) match {
+  override final def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = treeMap(tree) match {
     case impl @ Template(constr, parents, self, _) =>
       val tmap = withMappedSyms(localSyms(impl :: self :: Nil))
       cpy.Template(impl)(

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

@@ -175,11 +175,27 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
               val tmap: (Tree => Tree) = _ match {
                 case Return(t, from) if from.symbol == tree.symbol => Return(t, ref(newSym))
                 case t: TypeApply => transformTypeApply(t)
-                case t: Apply => transformApply(t)
+                case t: Apply =>
+                  transformApply(t)
                 case t => t
               }
+              val tp = new TreeMap() {
+                  // needed to workaround https://github.com/lampepfl/dotty/issues/592
+                  override def transform(t: Tree)(implicit ctx: Context) = super.transform(t) match {
+                  case t @ Apply(fun, args) =>
+                    val newArgs = (args zip fun.tpe.firstParamTypes).map{case(t, tpe) => t.ensureConforms(tpe)}
+                    if (sameTypes(args, newArgs)) {
+                      t
+                    } else tpd.Apply(fun, newArgs)
+                  case t: ValDef =>
+                    cpy.ValDef(t)(rhs = t.rhs.ensureConforms(t.tpe.widen))
+                  case t: DefDef =>
+                    cpy.DefDef(t)(rhs = t.rhs.ensureConforms(t.tpe.finalResultType))
+                  case t => t
+                }
+              }
 
-              new TreeTypeMap(
+              val typesReplaced = new TreeTypeMap(
                 treeMap = tmap,
                 typeMap = _
                     .substDealias(origTParams, instantiations(index))
@@ -188,6 +204,9 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
                 oldOwners = tree.symbol :: Nil,
                 newOwners = newSym :: Nil
               ).transform(tree.rhs)
+
+              val expectedTypeFixed = tp.transform(typesReplaced)
+              expectedTypeFixed.ensureConforms(newSym.info.widen.finalResultType)
             }})
           }
         } else Nil

tests/pos/specialization/this_specialization.scala

@@ -1,8 +1,14 @@
-sealed abstract class Foo[@specialized +A] {
+trait Foo[@specialized +A] {
+// all those examples trigger bugs due to https://github.com/lampepfl/dotty/issues/592
   def bop[@specialized B >: A]: Foo[B] = new Bar[B](this)
+  def gwa[@specialized B >: A]: Foo[B] = this
+  def gwd[@specialized B >: A]: Foo[B] = {
+    val d: Foo[B] = this
+    d
+  }
   //def bip[@specialized C >: A, @specialized D >: A]: Foo[D] = new Cho[D, C](new Bar[C](this))
 }
 
 case class Bar[@specialized a](tl: Foo[a]) extends Foo[a]
 
-//case class Cho[@specialized c, @specialized d](tl: Bar[d]) extends Foo[c]
+//case class Cho[@specialized c, @specialized d](tl: Bar[d]) extends Foo[c]