Erasure: properly erase value classes

There are three ways to erase a value class:
- In most case, it should be erased to an ErasedValueType, which will be
  erased in the next phase to its underlying type by
  ElimErasedValueType (not yet present in this commit). This corresponds
  to isSemi = true in TypeErasure.
- In a few cases, it should be erased like a normal class, so far this
  seems to be necessary for:
  * The return type of a constructor
  * The underlying type of a ThisType
  * TypeTree nodes inside New nodes
  * TypeApply nodes
  In these cases, we set isSemi = false
- When calling `sigName` it should be erased to its underlying type.

This commit implements all these cases. Note that this breaks most tests
because ElimErasedValueType has not been implemented yet, it is part of
the next commit.

Author: smarter

src/dotty/tools/dotc/TypeErasure.scala

@@ -5,6 +5,7 @@ package core
 import Symbols._, Types._, Contexts._, Flags._, Names._, StdNames._, Decorators._, Flags.JavaDefined
 import Uniques.unique
 import dotc.transform.ExplicitOuter._
+import dotc.transform.ValueClasses._
 import typer.Mode
 import util.DotClass
 
@@ -32,6 +33,8 @@ object TypeErasure {
    *  isInstanceOf may have types that do not satisfy the predicate.
    */
   def isErasedType(tp: Type)(implicit ctx: Context): Boolean = tp match {
+    case _: ErasedValueType =>
+      true
     case tp: TypeRef =>
       tp.symbol.isClass && tp.symbol != defn.AnyClass
     case _: TermRef =>
@@ -270,10 +273,12 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
    *   - For any other type, exception.
    */
   private def apply(tp: Type)(implicit ctx: Context): Type = tp match {
+    case _: ErasedValueType =>
+      tp
     case tp: TypeRef =>
       val sym = tp.symbol
       if (!sym.isClass) this(tp.info)
-      else if (sym.isDerivedValueClass) eraseDerivedValueClassRef(tp)
+      else if (isSemi && isDerivedValueClass(sym)) eraseDerivedValueClassRef(tp)
       else eraseNormalClassRef(tp)
     case tp: RefinedType =>
       val parent = tp.parent
@@ -282,7 +287,8 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
     case tp: TermRef =>
       this(tp.widen)
     case tp: ThisType =>
-      this(tp.cls.typeRef)
+      val thisTypeErasure = erasureFn(isJava, isSemi = false, isConstructor, wildcardOK)(_)
+      thisTypeErasure(tp.cls.typeRef)
     case SuperType(thistpe, supertpe) =>
       SuperType(this(thistpe), this(supertpe))
     case ExprType(rt) =>
@@ -352,8 +358,12 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
     case tp => this(tp)
   }
 
-  private def eraseDerivedValueClassRef(tref: TypeRef)(implicit ctx: Context): Type =
-    unsupported("eraseDerivedValueClass")
+  private def eraseDerivedValueClassRef(tref: TypeRef)(implicit ctx: Context): Type = {
+    val cls = tref.symbol.asClass
+    val underlying = underlyingOfValueClass(cls)
+    ErasedValueType(cls, erasure(underlying, isSemi = false))
+  }
+
 
   private def eraseNormalClassRef(tref: TypeRef)(implicit ctx: Context): Type = {
     val cls = tref.symbol.asClass
@@ -365,7 +375,7 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
     case tp: TypeRef =>
       val sym = tp.typeSymbol
       if (sym eq defn.UnitClass) sym.typeRef
-      else if (sym.isDerivedValueClass) eraseNormalClassRef(tp)
+      else if (isConstructor && isDerivedValueClass(sym)) eraseNormalClassRef(tp)
       else this(tp)
     case RefinedType(parent, _) if !(parent isRef defn.ArrayClass) =>
       eraseResult(parent)
@@ -387,10 +397,12 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
    *  Need to ensure correspondence with erasure!
    */
   private def sigName(tp: Type)(implicit ctx: Context): TypeName = tp match {
+    case ErasedValueType(_, underlying) =>
+      sigName(underlying)
     case tp: TypeRef =>
       val sym = tp.symbol
       if (!sym.isClass) sigName(tp.info)
-      else if (sym.isDerivedValueClass) sigName(eraseDerivedValueClassRef(tp))
+      else if (isDerivedValueClass(sym)) sigName(eraseDerivedValueClassRef(tp))
       else normalizeClass(sym.asClass).fullName.asTypeName
     case defn.ArrayType(elem) =>
       sigName(this(tp))

src/dotty/tools/dotc/core/Symbols.scala

@@ -417,11 +417,6 @@ object Symbols {
     /** If this symbol satisfies predicate `p` this symbol, otherwise `NoSymbol` */
     def filter(p: Symbol => Boolean): Symbol = if (p(this)) this else NoSymbol
 
-    /** Is this symbol a user-defined value class? */
-    final def isDerivedValueClass(implicit ctx: Context): Boolean =
-      false  // will migrate to ValueClasses.isDerivedValueClass;
-               // unsupported value class code will continue to use this stub while it exists
-
     /** The current name of this symbol */
     final def name(implicit ctx: Context): ThisName = denot.name.asInstanceOf[ThisName]
 

src/dotty/tools/dotc/core/TypeComparer.scala

@@ -139,6 +139,19 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
   }
 
   private def firstTry(tp1: Type, tp2: Type): Boolean = tp2 match {
+    // FIXME: This is needed because sometimes (underlying1 ne underlying2)
+    // but (underyling1 =:= underlying2). I don't know if there's a better
+    // solution.
+    case TypeErasure.ErasedValueType(cls2, underlying2) =>
+      def compareErasedValueType = {
+        tp1 match {
+          case TypeErasure.ErasedValueType(cls1, underlying1) =>
+            (cls1 eq cls2) && (underlying1 =:= underlying2)
+          case _ =>
+            secondTry(tp1, tp2)
+        }
+      }
+      compareErasedValueType
     case tp2: NamedType =>
       def compareAlias(info1: Type) = tp2.info match {
         case info2: TypeAlias => isSubType(tp1, info2.alias)

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

@@ -247,18 +247,31 @@ object Erasure extends TypeTestsCasts{
   class Typer extends typer.ReTyper with NoChecking {
     import Boxing._
 
-    def erasedType(tree: untpd.Tree)(implicit ctx: Context): Type = tree.typeOpt match {
-      case tp: TermRef if tree.isTerm => erasedRef(tp)
-      case tp => erasure(tp)
-    }
+    def erasedType(tree: untpd.Tree, isSemi: Boolean = true)(implicit ctx: Context): Type =
+      tree.typeOpt match {
+        case tp: TermRef if tree.isTerm => erasedRef(tp)
+        case tp => erasure(tp, isSemi)
+      }
 
-    override def promote(tree: untpd.Tree)(implicit ctx: Context): tree.ThisTree[Type] = {
+    def promote(tree: untpd.Tree, isSemi: Boolean)(implicit ctx: Context): tree.ThisTree[Type] = {
       assert(tree.hasType)
-      val erased = erasedType(tree)
+      val erased = erasedType(tree, isSemi)
       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)
+    }
+
+    override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(implicit ctx: Context): TypeTree = {
+      // TypeTree inside New nodes should not semi-erase value types.
+      // This is not the case for DefDef.tpt and ValDef.tpt but they are already
+      // handled separately inside typedDefDef and typedValDef.
+      // FIXME: What about other TypeTree? Is it OK to not semi-erase them?
+      promote(tree, isSemi = false)
+    }
+
     override def typedLiteral(tree: untpd.Literal)(implicit ctc: Context): Literal =
       if (tree.typeOpt.isRef(defn.UnitClass)) tree.withType(tree.typeOpt)
       else super.typedLiteral(tree)
@@ -323,7 +336,7 @@ object Erasure extends TypeTestsCasts{
           assert(sym.isConstructor, s"${sym.showLocated}")
           select(qual, defn.ObjectClass.info.decl(sym.name).symbol)
         }
-        else if (qualIsPrimitive && !symIsPrimitive || qual.tpe.isErasedValueType)
+        else if (qualIsPrimitive && !symIsPrimitive || qual.tpe.widen.isErasedValueType)
           recur(box(qual))
         else if (!qualIsPrimitive && symIsPrimitive)
           recur(unbox(qual, sym.owner.typeRef))
@@ -342,7 +355,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))
+      untpd.Ident(tree.name).withPos(tree.pos).withType(erasedType(tree, isSemi = false))
 
     override def typedThis(tree: untpd.This)(implicit ctx: Context): Tree =
       if (tree.symbol == ctx.owner.enclosingClass || tree.symbol.isStaticOwner) promote(tree)

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

@@ -93,7 +93,7 @@ trait TypeTestsCasts {
           else
             derivedTree(qual, defn.Any_asInstanceOf, argType)
         }
-        def erasedArg = erasure(tree.args.head.tpe)
+        def erasedArg = erasure(tree.args.head.tpe, isSemi = false)
         if (sym eq defn.Any_isInstanceOf)
           transformIsInstanceOf(qual, erasedArg)
         else if (sym eq defn.Any_asInstanceOf)