Add empty case class params check. Add test. Fix existing tests.

Author: ashwinbhaskar

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2396,7 +2396,15 @@ object Parsers {
         }
         else Nil
       }
-      recur(firstClause = true, 0, ofInstance)
+
+      val start = in.lastOffset
+      val params = recur(firstClause = true, 0, ofInstance)
+
+      if (ofCaseClass && params.isEmpty)
+        syntaxError( "case classes without a parameter list are not allowed;\n"+
+          "use either case objects or case classes with an explicit `()' as a parameter list.", start)
+
+      params
     }
 
 /* -------- DEFS ------------------------------------------- */

tests/neg/EmptyCaseClassParams.check

@@ -0,0 +1,15 @@
+-- Error: tests/neg/EmptyCaseClassParams.scala:2:17 --------------------------------------------------------------------
+2 |  case class A[T] // error
+  |                 ^
+  |                 case classes without a parameter list are not allowed;
+  |                 use either case objects or case classes with an explicit `()' as a parameter list.
+-- Error: tests/neg/EmptyCaseClassParams.scala:5:17 --------------------------------------------------------------------
+5 |  case class B[T] // error
+  |                 ^
+  |                 case classes without a parameter list are not allowed;
+  |                 use either case objects or case classes with an explicit `()' as a parameter list.
+-- Error: tests/neg/EmptyCaseClassParams.scala:9:13 --------------------------------------------------------------------
+9 |    case D[T] extends Foo[T] // error
+  |             ^
+  |             case classes without a parameter list are not allowed;
+  |             use either case objects or case classes with an explicit `()' as a parameter list.

tests/neg/EmptyCaseClassParams.scala

@@ -0,0 +1,11 @@
+object EmptyCaseClassParams{
+  case class A[T] // error
+
+  class C
+  case class B[T] // error
+    extends C
+
+  enum Foo[T]{
+    case D[T] extends Foo[T] // error
+  }
+}

tests/neg/derive-eq.scala

@@ -9,7 +9,7 @@ enum Lst[T] derives Eql {
   case Nil()
 }
 
-case class Triple[S, T, U] derives Eql
+case class Triple[S, T, U]() derives Eql
 
 
 object Test extends App {

tests/neg/enumsAccess.scala

@@ -5,7 +5,7 @@ object test1 {
   enum E4 {
     case C1(x: INT) // error: illegal reference
     case C2(x: Int = defaultX) // error: illegal reference
-    case C3[T <: INT] // error: illegal reference
+    case C3[T <: INT]() // error: illegal reference
   }
 
   object E4 {
@@ -24,7 +24,7 @@ object test2 {
   enum E5 {
     case C1(x: INT) // ok
     case C2(x: Int = defaultX) // ok
-    case C3[T <: INT] // ok
+    case C3[T <: INT]() // ok
   }
 }
 
@@ -39,7 +39,7 @@ object test3 {
   enum E5 {
     case C1(x: INT) // ok
     case C2(x: Int = defaultX)// ok
-    case C3[T <: INT] // ok
+    case C3[T <: INT]() // ok
   }
 }
 
@@ -48,7 +48,7 @@ object test4 {
   enum E5 {
     case C1(x: INT) // error: illegal reference
     case C2(x: Int = defaultX) // error: illegal reference
-    case C3[T <: INT] // error: illegal reference
+    case C3[T <: INT]() // error: illegal reference
   }
 
   import E5._
@@ -76,7 +76,7 @@ object test6 {
   import E5._
   enum E5[T](x: T) {
     case C3() extends E5[INT](defaultX) // ok
-    case C4 extends E5[INT](defaultX) // ok
+    case C4() extends E5[INT](defaultX) // ok
   }
 
   object E5 {
@@ -90,7 +90,7 @@ object test7 {
   trait Arg
 
   enum E(x: Arg) {
-    case C extends E(this) // error: illegal reference to `this`
+    case C() extends E(this) // error: illegal reference to `this`
   }
   object E extends Arg
 }

tests/neg/parser-stability-19.scala

@@ -1,5 +1,5 @@
 object x0 {
-  case class x0[]                     // error // error
+  case class x0[]()                     // error // error
     def x0( ) ]                       // error // error
     def x0 ( x0:x0 ):x0.type = x1 x0  // error // error
 // error

tests/neg/typeclass-derivation2.scala

@@ -101,10 +101,10 @@ object TypeLevel {
   enum Shape {
 
     /** A sum with alternative types `Alts` */
-    case Cases[Alts <: Tuple]
+    case Cases[Alts <: Tuple]()
 
     /** A product type `T` with element types `Elems` */
-    case Case[T, Elems <: Tuple]
+    case Case[T, Elems <: Tuple]()
   }
 
   /** Every generic derivation starts with a typeclass instance of this type.

tests/pos/gadt-GadtStlc.scala

@@ -10,7 +10,7 @@ object GadtStlc {
   // Var[M[W]]
   sealed trait Var[A]
   object VarW extends Var[W]
-  case class VarM[A] extends Var[M[A]]
+  case class VarM[A]() extends Var[M[A]]
 
   // \s.e
   sealed trait Abs[S, E]

tests/pos/i4176-gadt.scala

@@ -1,7 +1,7 @@
 object i4176 {
   sealed trait TNat
   case class TZero() extends TNat
-  case class TSucc[N <: TNat] extends TNat
+  case class TSucc[N <: TNat]() extends TNat
 
   object TNatSum {
     sealed trait TSum[M, N, R]

tests/pos/i4316.scala

@@ -1,6 +1,6 @@
 object Test {
 
-  case class Bar[A]
+  case class Bar[A]()
 
   def meth[A](consumer: A => Unit, s: Bar[A]): Unit = {
     s match {

tests/run/derive-multi.scala

@@ -26,7 +26,7 @@ enum Lst[T] derives A, B {
   case Nil()
 }
 
-case class Triple[S, T, U] derives A, B
+case class Triple[S, T, U]() derives A, B
 
 object Test1 {
   import Lst._

tests/run/typeclass-derivation2.scala

@@ -103,10 +103,10 @@ object TypeLevel {
   enum Shape {
 
     /** A sum with alternative types `Alts` */
-    case Cases[Alts <: Tuple]
+    case Cases[Alts <: Tuple]()
 
     /** A product type `T` with element types `Elems` */
-    case Case[T, Elems <: Tuple]
+    case Case[T, Elems <: Tuple]()
   }
 
   /** Every generic derivation starts with a typeclass instance of this type.

tests/run/typeclass-derivation2a.scala

@@ -88,10 +88,10 @@ object TypeLevel {
   enum Shape {
 
     /** A sum with alternative types `Alts` */
-    case Cases[Alts <: Tuple]
+    case Cases[Alts <: Tuple]()
 
     /** A product type `T` with element types `Elems` */
-    case Case[T, Elems <: Tuple]
+    case Case[T, Elems <: Tuple]()
   }
 
   /** Every generic derivation starts with a typeclass instance of this type.