Simplify logic in erasure.

There's one behavioral change: on typedSelectFromTypeTree, we use erasedType as for a notmal ref.
Before semiEraseVCs was always set to false here. I don't see how the treatment should be different.
E.g. it should not matter if we see a

     x.y
or

     T#y

1 files changed, 10 insertions, 17 deletions

diff --git a/src/dotty/tools/dotc/transform/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala
index 663c309c0..8446e2626 100644
--- a/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/src/dotty/tools/dotc/transform/Erasure.scala
@@ -268,36 +268,29 @@ object Erasure extends TypeTestsCasts{
   class Typer extends typer.ReTyper with NoChecking {
     import Boxing._
 
-    def erasedType(tree: untpd.Tree, semiEraseVCs: Boolean)(implicit ctx: Context): Type =
-      tree.typeOpt match {
-        case tp: TermRef if tree.isTerm => erasedRef(tp)
-        case tp: ThisType => tp
-        case tp => erasure(tp, semiEraseVCs)
-      }
+    def erasedType(tree: untpd.Tree)(implicit ctx: Context): Type = {
+      val tp = tree.typeOpt
+      if (tree.isTerm) erasedRef(tp) else erasure(tp, semiEraseVCs = true)
+    }
 
-    def promote(tree: untpd.Tree, semiEraseVCs: Boolean)(implicit ctx: Context): tree.ThisTree[Type] = {
+    override def promote(tree: untpd.Tree)(implicit ctx: Context): tree.ThisTree[Type] = {
       assert(tree.hasType)
-      val erased = erasedType(tree, semiEraseVCs)
+      val erased = erasedType(tree)
       ctx.log(s"promoting ${tree.show}: ${erased.showWithUnderlying()}")
       tree.withType(erased)
     }
 
-    override def promote(tree: untpd.Tree)(implicit ctx: Context): tree.ThisTree[Type] = {
-      promote(tree, true)
-    }
-
     /** When erasing most TypeTrees we should not semi-erase value types.
      *  This is not the case for [[DefDef#tpt]], [[ValDef#tpt]] and [[Typed#tpt]], they
      *  are handled separately by [[typedDefDef]], [[typedValDef]] and [[typedTyped]].
      */
-    override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(implicit ctx: Context): TypeTree = {
-      promote(tree, semiEraseVCs = false)
-    }
+    override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(implicit ctx: Context): TypeTree =
+      tree.withType(erasure(tree.tpe, semiEraseVCs = false))
 
     /** This override is only needed to semi-erase type ascriptions */
     override def typedTyped(tree: untpd.Typed, pt: Type)(implicit ctx: Context): Tree = {
       val Typed(expr, tpt) = tree
-      val tpt1 = promote(tpt, semiEraseVCs = true)
+      val tpt1 = promote(tpt)
       val expr1 = typed(expr, tpt1.tpe)
       assignType(untpd.cpy.Typed(tree)(expr1, tpt1), tpt1)
     }
@@ -385,7 +378,7 @@ object Erasure extends TypeTestsCasts{
     }
 
     override def typedSelectFromTypeTree(tree: untpd.SelectFromTypeTree, pt: Type)(implicit ctx: Context) =
-      untpd.Ident(tree.name).withPos(tree.pos).withType(erasedType(tree, semiEraseVCs = false))
+      untpd.Ident(tree.name).withPos(tree.pos).withType(erasedType(tree))
 
     override def typedThis(tree: untpd.This)(implicit ctx: Context): Tree =
       if (tree.symbol == ctx.owner.enclosingClass || tree.symbol.isStaticOwner) promote(tree)