fix #1642: disallow value classe wrapping value class

Author: liufengyun

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

@@ -427,7 +427,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
   private def eraseDerivedValueClassRef(tref: TypeRef)(implicit ctx: Context): Type = {
     val cls = tref.symbol.asClass
     val underlying = underlyingOfValueClass(cls)
-    if (underlying.exists) ErasedValueType(tref, valueErasure(underlying))
+    if (underlying.exists && !isCyclic(cls)) ErasedValueType(tref, valueErasure(underlying))
     else NoType
   }
 

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

@@ -135,14 +135,6 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful
   // TODO: this is state and should be per-run
   // todo: check that when transformation finished map is empty
 
-  private def checkNonCyclic(pos: Position, seen: Set[Symbol], clazz: ClassSymbol)(implicit ctx: Context): Unit =
-    if (seen contains clazz)
-      ctx.error("value class may not unbox to itself", pos)
-    else {
-      val unboxed = underlyingOfValueClass(clazz).typeSymbol
-      if (isDerivedValueClass(unboxed)) checkNonCyclic(pos, seen + clazz, unboxed.asClass)
-    }
-
   override def transformTemplate(tree: tpd.Template)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
     if (isDerivedValueClass(ctx.owner)) {
       /* This is currently redundant since value classes may not

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

@@ -53,4 +53,14 @@ object ValueClasses {
   def underlyingOfValueClass(d: ClassDenotation)(implicit ctx: Context): Type =
     valueClassUnbox(d).info.resultType
 
+  /** Whether a value class wraps itself */
+  def isCyclic(cls: ClassSymbol)(implicit ctx: Context): Boolean = {
+    def recur(seen: Set[Symbol], clazz: ClassSymbol)(implicit ctx: Context): Boolean =
+      (seen contains clazz) || {
+        val unboxed = underlyingOfValueClass(clazz).typeSymbol
+        (isDerivedValueClass(unboxed)) && recur(seen + clazz, unboxed.asClass)
+      }
+
+    recur(Set[Symbol](), cls)
+  }
 }

src/dotty/tools/dotc/typer/RefChecks.scala

@@ -18,7 +18,7 @@ import config.{ScalaVersion, NoScalaVersion}
 import Decorators._
 import typer.ErrorReporting._
 import DenotTransformers._
-import ValueClasses.isDerivedValueClass
+import ValueClasses.{isDerivedValueClass, isCyclic}
 
 object RefChecks {
   import tpd._
@@ -714,12 +714,15 @@ object RefChecks {
         ctx.error("`abstract' modifier cannot be used with value classes", clazz.pos)
       if (!clazz.isStatic)
         ctx.error(s"value class may not be a ${if (clazz.owner.isTerm) "local class" else "member of another class"}", clazz.pos)
+      if (isCyclic(clazz.asClass))
+        ctx.error("value class cannot wrap itself", clazz.pos)
       else {
-        val clParamAccessors = clazz.asClass.paramAccessors.filter(sym => sym.isTerm && !sym.is(Method))
+        val clParamAccessors = clazz.asClass.paramAccessors.filter(_.isTerm)
         clParamAccessors match {
           case List(param) =>
             if (param.is(Mutable))
               ctx.error("value class parameter must not be a var", param.pos)
+
           case _ =>
             ctx.error("value class needs to have exactly one val parameter", clazz.pos)
         }

src/dotty/tools/dotc/typer/Typer.scala

@@ -1265,7 +1265,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           cls, isRequired, cdef.pos)
     }
 
-
     // check value class constraints
     RefChecks.checkDerivedValueClass(cls, body1)
 

tests/neg/i1642.scala

@@ -0,0 +1 @@
+class Test2(val valueVal: Test2) extends AnyVal

tests/neg/i1670.scala

@@ -1 +1 @@
-class A(a:Int, b:Int) extends AnyVal
+class A(a:Int, b:Int) extends AnyVal

tests/pos/i1642.scala

@@ -0,0 +1,3 @@
+class Test1(val x: Int) extends AnyVal
+class Test2(val y: Test1) extends AnyVal
+