Check value class member restrictions

According to SIP 15 a value class C must obey the following restrictions:

C may not have secondary constructors.
C may not declare fields (other than the parameter of a value class).
C may not contain object definitions.
C may not have initialization statements.

These are enforced by this commit. We are still missing restrictions on
value class paremeters. We should review what the right set of conditions
is (probably we want to admit non-vals, and maybe even multiple
parameters).

Author: odersky

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

@@ -655,15 +655,27 @@ object RefChecks {
   }
 
   /** Verify classes extending AnyVal meet the requirements */
-  private def checkDerivedValueClass(clazz: Symbol)(implicit ctx: Context) =
+  private def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context) = {
+    def checkValueClassMember(stat: Tree) = stat match {
+      case _: ValDef if !stat.symbol.is(ParamAccessor) =>
+        ctx.error(s"value class may not define non-parameter field", stat.pos)
+      case _: DefDef if stat.symbol.isConstructor =>
+        ctx.error(s"value class may not define secondary constructor", stat.pos)
+      case _: MemberDef | _: Import | EmptyTree =>
+      // ok
+      case _ =>
+        ctx.error(s"value class may not contain initialization statements", stat.pos)
+    }
     if (isDerivedValueClass(clazz)) {
       if (clazz.is(Trait))
         ctx.error("Only classes (not traits) are allowed to extend AnyVal", clazz.pos)
       if (clazz.is(Abstract))
         ctx.error("`abstract' modifier cannot be used with value classes", clazz.pos)
       if (!clazz.isStatic)
         ctx.error("value class cannot be an inner class", clazz.pos)
+      stats.foreach(checkValueClassMember)
     }
+  }
 
   type LevelAndIndex = immutable.Map[Symbol, (LevelInfo, Int)]
 
@@ -780,7 +792,7 @@ class RefChecks extends MiniPhase { thisTransformer =>
       checkParents(cls)
       checkCompanionNameClashes(cls)
       checkAllOverrides(cls)
-      checkDerivedValueClass(cls)
+      checkDerivedValueClass(cls, tree.body)
       tree
     }
 

test/dotc/tests.scala

@@ -134,7 +134,7 @@ class tests extends CompilerTest {
   @Test def neg_i0281 = compileFile(negDir, "i0281-null-primitive-conforms", xerrors = 3)
   @Test def neg_i583 = compileFile(negDir, "i0583-skolemize", xerrors = 2)
   @Test def neg_finalSealed = compileFile(negDir, "final-sealed", xerrors = 2)
-  @Test def neg_i705 = compileFile(negDir, "i705-inner-value-class", xerrors = 3)
+  @Test def neg_i705 = compileFile(negDir, "i705-inner-value-class", xerrors = 7)
   @Test def neg_moduleSubtyping = compileFile(negDir, "moduleSubtyping", xerrors = 4)
   @Test def neg_escapingRefs = compileFile(negDir, "escapingRefs", xerrors = 2)
   @Test def neg_instantiateAbstract = compileFile(negDir, "instantiateAbstract", xerrors = 8)

tests/neg/i705-inner-value-class.scala

@@ -2,6 +2,13 @@ class Foo {
   class B(val a: Int) extends AnyVal // error
 }
 
+class VCwithBadMembers(val a: Int) extends AnyVal {
+  def this() = this(1) // error
+  var x = 0 // error
+  val y = 2 // error
+  println("hi") // error
+}
+
 object Test {
   class B(val a: Int) extends AnyVal // ok
   def f = {

tests/pos/extmethods.scala

@@ -1,7 +1,6 @@
 trait That1[A]
 class T[A, This <: That1[A]](val x: Int) extends AnyVal {
   self: This =>
-  var next: This = _
   final def loop(x: This, cnt: Int): Int = loop(x, cnt + 1)
   def const[B](): Boolean = return true
 }