New phase VCParents: add parents to value classes and their companions

Note that this mean that the following does not pass Ycheck after VCParents:
  def foo[T <: AnyVal](...)
  foo[Meter](...)
Ycheck will complain that Meter does not conform to the upper bound
AnyVal, which is true. I'm not sure what the best way to deal with this is.

Author: smarter

src/dotty/tools/dotc/Compiler.scala

@@ -46,6 +46,7 @@ class Compiler {
            new ElimRepeated,
            new NormalizeFlags,
            new ExtensionMethods,
+           new VCParents,
            new ExpandSAMs,
            new TailRec,
            new ClassOf),

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

@@ -4,6 +4,7 @@ package core
 
 import Types._, Contexts._, Symbols._, Denotations._, SymDenotations._, StdNames._, Names._
 import Flags._, Scopes._, Decorators._, NameOps._, util.Positions._
+import transform.ValueClasses
 import unpickleScala2.Scala2Unpickler.ensureConstructor
 import scala.annotation.{ switch, meta }
 import scala.collection.{ mutable, immutable }
@@ -599,6 +600,31 @@ class Definitions {
   lazy val volatileRefClass: Map[Symbol, Symbol] =
     refClasses.map(rc => rc -> ctx.requiredClass(s"scala.runtime.Volatile${rc.name}Ref")).toMap
 
+  lazy val vcPrototype: Map[Symbol, Symbol] =
+    refClasses.map(vc => vc -> ctx.requiredClass(s"dotty.runtime.vc.VC${vc.name}Prototype")).toMap
+  lazy val vcCompanion: Map[Symbol, Symbol] =
+    refClasses.map(vc => vc -> ctx.requiredClass(s"dotty.runtime.vc.VC${vc.name}Companion")).toMap
+  lazy val vcArray: Map[Symbol, Symbol] =
+    refClasses.map(vc => vc -> ctx.requiredClass(s"dotty.runtime.vc.VC${vc.name}Array")).toMap
+
+  lazy val VCArrayPrototypeClass = ctx.requiredClass(s"dotty.runtime.vc.VCArrayPrototype")
+  def VCArrayPrototypeType = VCArrayPrototypeClass.typeRef
+
+  def vcPrototypeOf(vc: ClassDenotation) = {
+    val underlying = ValueClasses.valueClassUnbox(vc).info.classSymbol
+    vcPrototype.getOrElse(underlying, vcPrototype(defn.ObjectClass))
+  }
+  def vcCompanionOf(vc: ClassDenotation) = {
+    val underlying = ValueClasses.valueClassUnbox(vc).info.classSymbol
+    vcCompanion.getOrElse(underlying, vcCompanion(defn.ObjectClass))
+  }
+  def vcArrayOf(vc: ClassDenotation) = {
+    val underlying = ValueClasses.valueClassUnbox(vc).info.classSymbol
+    vcArray.getOrElse(underlying, vcArray(defn.ObjectClass))
+  }
+
+
+
   def wrapArrayMethodName(elemtp: Type): TermName = {
     val cls = elemtp.classSymbol
     if (cls.isPrimitiveValueClass) nme.wrapXArray(cls.name)

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

@@ -72,28 +72,12 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful
             val evt2uSym = ctx.newSymbol(moduleSym, nme.EVT2U, Synthetic | Method,
               MethodType(List(nme.x_0), List(evt), underlying))
 
-            val defn = ctx.definitions
-
-            val underlyingCls = underlying.classSymbol
-            val underlyingClsName =
-              if (defn.ScalaNumericValueClasses.contains(underlyingCls) ||
-                underlyingCls == defn.BooleanClass) underlyingCls.name else nme.Object
-
-
-            val syp = ctx.requiredClass(s"dotty.runtime.vc.VC${underlyingClsName}Companion").asClass
-
-            newSuperClass = tpd.ref(syp).select(nme.CONSTRUCTOR).appliedToType(valueClass.typeRef).tpe.resultType
-
             decls1.enter(u2evtSym)
             decls1.enter(evt2uSym)
           }
 
-          // Add the extension methods, the cast methods u2evt$ and evt2u$, and a VC*Companion superclass
-          moduleClassSym.copySymDenotation(info =
-            cinfo.derivedClassInfo(
-              // FIXME: use of VC*Companion superclasses is disabled until the conflicts with SyntheticMethods are solved.
-              //classParents = ctx.normalizeToClassRefs(List(newSuperClass), moduleSym, decls1),
-              decls = decls1))
+          // Add the extension methods, the cast methods u2evt$ and evt2u$
+          moduleClassSym.copySymDenotation(info = cinfo.derivedClassInfo(decls = decls1))
         case _ =>
           moduleClassSym
       }

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

@@ -0,0 +1,84 @@
+package dotty.tools.dotc
+package transform
+
+import ast.{Trees, tpd}
+import core._, core.Decorators._
+import Contexts._, Flags._, Trees._, Types._, StdNames._, Symbols._
+import Denotations._, SymDenotations._
+import DenotTransformers._, TreeTransforms._, Phases.Phase
+import ValueClasses._
+
+/** This phase makes value classes extend VCXPrototype and make their companions extend VCXCompanion.
+ *
+ *  For a value class class V whose erased underlying type is U, X is "U" if U is a primitive
+ *  type and is "Object" otherwise.
+ *
+ */
+class VCParents extends MiniPhaseTransform with DenotTransformer {
+  import tpd._
+
+  override def phaseName: String = "vcParents"
+
+  override def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref match {
+    case moduleClass: ClassDenotation if moduleClass.is(ModuleClass) =>
+      moduleClass.linkedClass match {
+        case valueClass: ClassSymbol if isDerivedValueClass(valueClass) =>
+          val moduleSym = moduleClass.symbol.asClass
+          val cinfo = moduleClass.classInfo
+
+          val superType = tpd.ref(defn.vcCompanionOf(valueClass))
+            .select(nme.CONSTRUCTOR)
+            .appliedToType(valueClass.typeRef)
+            .tpe
+            .resultType
+
+          moduleClass.copySymDenotation(info =
+            cinfo.derivedClassInfo(classParents =
+              ctx.normalizeToClassRefs(List(superType), moduleSym, cinfo.decls)))
+        case _ =>
+          moduleClass
+      }
+    case valueClass: ClassDenotation if isDerivedValueClass(valueClass) =>
+      val cinfo = valueClass.classInfo
+      val superType = defn.vcPrototypeOf(valueClass).typeRef
+
+      val (p :: ps) = cinfo.classParents
+      assert(p.isRef(defn.AnyValClass))
+      val parents = superType :: ps
+      valueClass.copySymDenotation(info = cinfo.derivedClassInfo(classParents = parents))
+    case _ =>
+      ref
+  }
+
+  override def transformTemplate(tree: tpd.Template)(implicit ctx: Context, info: TransformerInfo): tpd.Tree =
+    ctx.owner.denot match {
+      case moduleClass: ClassDenotation if moduleClass.is(ModuleClass) =>
+        moduleClass.linkedClass match {
+          case valueClass: ClassSymbol if isDerivedValueClass(valueClass) =>
+            val superCall = New(defn.vcCompanionOf(valueClass).typeRef)
+              .select(nme.CONSTRUCTOR)
+              .appliedToType(valueClass.typeRef)
+              .appliedToNone
+
+            val (p :: ps) = tree.parents
+            // TODO: We shouldn't disallow extending companion objects of value classes
+            // with classes other than AnyRef
+            assert(p.tpe.isRef(defn.ObjectClass))
+            cpy.Template(tree)(parents = superCall :: ps)
+          case _ =>
+            tree
+        }
+      case valueClass: ClassDenotation if isDerivedValueClass(valueClass) =>
+        val prototype = defn.vcPrototypeOf(valueClass).typeRef
+        val underlyingSym = valueClassUnbox(valueClass)
+        val superCall = New(prototype, List(ref(underlyingSym)))
+        // TODO: manually do parameter forwarding: the prototype has a local field
+        // so we don't need a field inside the value class
+
+        val (p :: ps) = tree.parents
+        assert(p.tpe.isRef(defn.AnyValClass))
+        cpy.Template(tree)(parents = superCall :: ps)
+      case _ =>
+        tree
+    }
+}