More extensive tests and relaed fixes

 - More extensive use cases
 - Defining enum cases with wrong kinds in extension clauses caused
   a crash in argDenot, which is fixed now.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -342,7 +342,7 @@ object desugar {
         .withPos(cdef.pos.startPos)
 
     def appliedRef(tycon: Tree, tparams: List[TypeDef] = constrTparams, widenHK: Boolean = false) = {
-      var targs = for (tparam <- tparams) yield {
+      val targs = for (tparam <- tparams) yield {
         val targ = refOfDef(tparam)
         def fullyApplied(tparam: Tree): Tree = tparam match {
           case TypeDef(_, LambdaTypeTree(tparams, body)) =>

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1754,21 +1754,25 @@ object Types {
 
       val idx = typeParams.indexOf(param)
 
-      assert(args.nonEmpty,
-      	i"""bad parameter reference $this at ${ctx.phase}
-      	   |the parameter is ${param.showLocated} but the prefix $prefix
-      	   |does not define any corresponding arguments.""")
-
-      val argInfo = args(idx) match {
-        case arg: TypeBounds =>
-          val v = param.paramVariance
-          val pbounds = param.paramInfo
-          if (v > 0 && pbounds.loBound.dealias.isBottomType) TypeAlias(arg.hiBound & rebase(pbounds.hiBound))
-          else if (v < 0 && pbounds.hiBound.dealias.isTopType) TypeAlias(arg.loBound | rebase(pbounds.loBound))
-          else arg recoverable_& rebase(pbounds)
-        case arg => TypeAlias(arg)
+      if (idx < args.length) {
+        val argInfo = args(idx) match {
+          case arg: TypeBounds =>
+            val v = param.paramVariance
+            val pbounds = param.paramInfo
+            if (v > 0 && pbounds.loBound.dealias.isBottomType) TypeAlias(arg.hiBound & rebase(pbounds.hiBound))
+            else if (v < 0 && pbounds.hiBound.dealias.isTopType) TypeAlias(arg.loBound | rebase(pbounds.loBound))
+            else arg recoverable_& rebase(pbounds)
+          case arg => TypeAlias(arg)
+        }
+        param.derivedSingleDenotation(param, argInfo)
+      }
+      else {
+        assert(ctx.reporter.errorsReported,
+          i"""bad parameter reference $this at ${ctx.phase}
+            |the parameter is ${param.showLocated} but the prefix $prefix
+            |does not define any corresponding arguments.""")
+        NoDenotation
       }
-      param.derivedSingleDenotation(param, argInfo)
     }
 
     /** Reload denotation by computing the member with the reference's name as seen

tests/neg/i3976.scala

@@ -0,0 +1,58 @@
+object Test {
+  enum Hoge[F[_]] {
+    case A extends Hoge[List]
+    case B extends Hoge[[X] => String]
+  }
+  import Hoge._
+
+  A == A
+  A == (B: Hoge[_])
+
+  A == B // error: cannot be compared
+
+  class C
+
+  A == "" // error: cannot be compared
+  A == new C // error: cannot be compared
+
+}
+
+object Test2 {
+  enum Hoge[F[G[_]]] {
+    case A extends Hoge[[F[_]] => F[Int]]
+    case B extends Hoge[[F[_]] => F[String]]
+  }
+  import Hoge._
+
+  A == A
+  A == (B: Hoge[_])
+
+  A == B
+
+  class C
+
+  A == "" // error: cannot be compared
+  A == new C // error: cannot be compared
+
+}
+
+object Test3 {
+  enum Hoge[F[G[_]]] {
+    case A extends Hoge[[X] => List]   // error: wrong kind
+    case B extends Hoge[[X] => [Y] => String]  // error: wrong kind
+  }
+  import Hoge._
+
+  A == A
+  A == (B: Hoge[_])
+
+  A == B
+
+  class C
+
+  A == ""
+  A == new C
+
+}
+
+

tests/pos/i3976.scala

@@ -1 +1,10 @@
-enum class Hoge[F[_]]
+object Test {
+  enum Hoge[F[_]] {
+    case A extends Hoge[List]
+    case B extends Hoge[[X] => String]
+  }
+  import Hoge._
+
+  A == A
+  A == (B: Hoge[_])
+}