Add synthetic casts to and from ErasedValueType

For a value class V, let U be the underlying type after
erasure. We add to the companion object of V two cast methods:

  def underlying2evt$(x0: U): ErasedValueType(V, U)
  def evt2underlying$(x0: V): ErasedValueType(U, V)

The casts are used in Erasure to make it typecheck, they are then removed
in ElimErasedValueType (not yet present in this commit). This is
different from the implementation of value classes in Scala 2 (see
SIP-15) which used `asInstanceOf` which does not typecheck.

Author: smarter

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

@@ -223,6 +223,7 @@ object StdNames {
     val ANYname: N                  = "<anyname>"
     val CONSTRUCTOR: N              = Names.CONSTRUCTOR.toString
     val DEFAULT_CASE: N             = "defaultCase$"
+    val EVT2UNDERLYING: N           = "evt2underlying$"
     val EQEQ_LOCAL_VAR: N           = "eqEqTemp$"
     val FAKE_LOCAL_THIS: N          = "this$"
     val IMPLCLASS_CONSTRUCTOR: N    = "$init$"
@@ -254,6 +255,7 @@ object StdNames {
     val SKOLEM: N                   = "<skolem>"
     val SPECIALIZED_INSTANCE: N     = "specInstance$"
     val THIS: N                     = "_$this"
+    val UNDERLYING2EVT: N           = "underlying2evt$"
 
     final val Nil: N                = "Nil"
     final val Predef: N             = "Predef"

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

@@ -192,6 +192,8 @@ object Erasure extends TypeTestsCasts{
 
     /** Generate a synthetic cast operation from tree.tpe to pt.
      *  Does not do any boxing/unboxing (this is handled upstream).
+     *  Casts from and to ErasedValueType are special, see the explanation
+     *  in ExtensionMethods#transform.
      */
     def cast(tree: Tree, pt: Type)(implicit ctx: Context): Tree = {
       // TODO: The commented out assertion fails for tailcall/t6574.scala
@@ -203,9 +205,18 @@ object Erasure extends TypeTestsCasts{
         if treeElem.widen.isPrimitiveValueType && !ptElem.isPrimitiveValueType =>
           // See SI-2386 for one example of when this might be necessary.
           cast(ref(defn.runtimeMethod(nme.toObjectArray)).appliedTo(tree), pt)
+        case (_, ErasedValueType(cls, _)) =>
+          ref(underlying2evtSym(cls)).appliedTo(tree)
         case _ =>
-          if (pt.isPrimitiveValueType) primitiveConversion(tree, pt.classSymbol)
-          else tree.asInstance(pt)
+          tree.tpe.widen match {
+            case ErasedValueType(cls, _) =>
+              ref(evt2underlyingSym(cls)).appliedTo(tree)
+            case _ =>
+              if (pt.isPrimitiveValueType)
+                primitiveConversion(tree, pt.classSymbol)
+              else
+                tree.asInstance(pt)
+          }
       }
     }
 

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

@@ -14,9 +14,11 @@ import core._
 import Phases.Phase
 import Types._, Contexts._, Constants._, Names._, NameOps._, Flags._, DenotTransformers._
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Scopes._, Denotations._
+import TypeErasure.{ erasure, ErasedValueType }
 import TypeUtils._
 import util.Positions._
 import Decorators._
+import SymUtils._
 
 /**
  * Perform Step 1 and 2 in the value classes SIP: Creates extension methods for all
@@ -34,15 +36,36 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful
   override def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref match {
     case ref: ClassDenotation if ref is ModuleClass =>
       ref.linkedClass match {
-        // In Scala 2, extension methods are added before pickling so we should not generate them again
-        case origClass: ClassSymbol if isDerivedValueClass(origClass) && !(origClass is Scala2x) =>
+        case origClass: ClassSymbol if isDerivedValueClass(origClass) =>
           val cinfo = ref.classInfo
           val decls1 = cinfo.decls.cloneScope
           ctx.atPhase(thisTransformer.next) { implicit ctx =>
-            for (decl <- origClass.classInfo.decls) {
-              if (isMethodWithExtension(decl))
-                decls1.enter(createExtensionMethod(decl, ref.symbol))
+            // In Scala 2, extension methods are added before pickling so we should
+            // not generate them again.
+            if (!(origClass is Scala2x)) {
+              for (decl <- origClass.classInfo.decls) {
+                if (isMethodWithExtension(decl))
+                  decls1.enter(createExtensionMethod(decl, ref.symbol))
+              }
             }
+
+            // For a value class V, let U be the underlying type after erasure. We add
+            // to the companion object of V two cast methods:
+            //   def underlying2evt$(x0: U): ErasedValueType(V, U)
+            //   def evt2underlying$(x0: V): ErasedValueType(U, V)
+            // The casts are used in Erasure to make it typecheck, they are then removed
+            // in ElimErasedValueType.
+            // This is different from the implementation of value classes in Scala 2
+            // (see SIP-15) which used `asInstanceOf` which does not typecheck.
+            val sym = ref.symbol
+            val underlying = erasure(underlyingOfValueClass(origClass))
+            val evt = ErasedValueType(origClass, underlying)
+            val underlying2evtSym = ctx.newSymbol(sym, nme.UNDERLYING2EVT, Method,
+              MethodType(List(nme.x_0), List(underlying), evt))
+            val evt2underlyingSym = ctx.newSymbol(sym, nme.EVT2UNDERLYING, Method,
+              MethodType(List(nme.x_0), List(evt), underlying))
+            decls1.enter(underlying2evtSym)
+            decls1.enter(evt2underlyingSym)
           }
           if (decls1.isEmpty) ref
           else ref.copySymDenotation(info = cinfo.derivedClassInfo(decls = decls1))

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

@@ -7,6 +7,7 @@ import Symbols._
 import SymDenotations._
 import Contexts._
 import Flags._
+import StdNames._
 
 /** Methods that apply to user-defined value classes */
 object ValueClasses {
@@ -32,6 +33,11 @@ object ValueClasses {
       .map(_.symbol)
       .getOrElse(NoSymbol)
 
+  def underlying2evtSym(d: ClassDenotation)(implicit ctx: Context): Symbol =
+    d.linkedClass.info.decl(nme.UNDERLYING2EVT).symbol
+  def evt2underlyingSym(d: ClassDenotation)(implicit ctx: Context): Symbol =
+    d.linkedClass.info.decl(nme.EVT2UNDERLYING).symbol
+
   /** The unboxed type that underlies a derived value class */
   def underlyingOfValueClass(d: ClassDenotation)(implicit ctx: Context): Type =
     valueClassUnbox(d).info.resultType