Implement variance checking for parameters of type lambdas.

Author: odersky

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

@@ -1307,7 +1307,8 @@ class Typer extends Namer
     index(tparams)
     val tparams1 = tparams.mapconserve(typed(_).asInstanceOf[TypeDef])
     val body1 = typedType(tree.body)
-    assignType(cpy.LambdaTypeTree(tree)(tparams1, body1), tparams1, body1)
+    VarianceChecker.checkLambda(
+      assignType(cpy.LambdaTypeTree(tree)(tparams1, body1), tparams1, body1))
   }
 
   def typedMatchTypeTree(tree: untpd.MatchTypeTree, pt: Type)(implicit ctx: Context): Tree = {
@@ -1500,7 +1501,8 @@ class Typer extends Namer
       case rhs @ LambdaTypeTree(tparams, body) =>
         val tparams1 = tparams.map(typed(_)).asInstanceOf[List[TypeDef]]
         val body1 = typedType(body)
-        assignType(cpy.LambdaTypeTree(rhs)(tparams1, body1), tparams1, body1)
+        VarianceChecker.checkLambda(
+          assignType(cpy.LambdaTypeTree(rhs)(tparams1, body1), tparams1, body1))
       case rhs =>
         typedType(rhs)
     }

compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala

@@ -7,6 +7,7 @@ import Types._, Contexts._, Flags._, Symbols._, Trees._
 import Decorators._
 import Variances._
 import NameKinds._
+import TypeApplications.varianceConforms
 import util.Positions._
 import config.Printers.variances
 import reporting.trace
@@ -19,6 +20,44 @@ object VarianceChecker {
   case class VarianceError(tvar: Symbol, required: Variance)
   def check(tree: tpd.Tree)(implicit ctx: Context): Unit =
     new VarianceChecker()(ctx).Traverser.traverse(tree)
+
+  /** Check that variances of type lambda correspond to their occurrences in its body.
+   *  Note: this is achieved by a mechanism separate from checking class type parameters.
+   *  Question: Can the two mechanisms be combined in one?
+   */
+  def checkLambda(tree: tpd.LambdaTypeTree)(implicit ctx: Context): tree.type = {
+    tree.tpe match {
+      case tl: HKTypeLambda =>
+        val checkOK = new TypeAccumulator[Boolean] {
+          def error(tref: TypeParamRef) = {
+            val VariantName(paramName, v) = tl.paramNames(tref.paramNum).toTermName
+            val paramVarianceStr = if (v == 0) "contra" else "co"
+            val occursStr = variance match {
+              case -1 => "contra"
+              case 0 => "non"
+              case 1 => "co"
+            }
+            val pos = tree.tparams
+              .find(_.name.toTermName == paramName)
+              .map(_.pos)
+              .getOrElse(tree.pos)
+            ctx.error(em"${paramVarianceStr}variant type parameter $paramName occurs in ${occursStr}variant position in ${tl.resType}", pos)
+          }
+          def apply(x: Boolean, t: Type) = x && {
+            t match {
+              case tref: TypeParamRef if tref.binder `eq` tl =>
+                val v = tl.typeParams(tref.paramNum).paramVariance
+                varianceConforms(variance, v) || { error(tref); false }
+              case _ =>
+                foldOver(x, t)
+            }
+          }
+        }
+        checkOK.apply(true, tl.resType)
+      case _ =>
+    }
+    tree
+  }
 }
 
 class VarianceChecker()(implicit ctx: Context) {

tests/neg/type-lambdas.scala

@@ -3,7 +3,7 @@ object Test extends App {
   trait Ord[X]
 
   type TL1 = [X <: Ord[X]] => (X, X) // OK
-  type TL2 = [X >: Ord[X]] => (X, X) // error
+  type TL2 = [X >: Ord[X]] => (X, X) // error: illegal cyclic reference: lower bound Test.Ord[X] of type X refers back to the type itself
 
   class C extends Ord[C]
 
@@ -14,7 +14,8 @@ object Test extends App {
     var x: X = init
   }
 
-  type TL3 = [+X] => Ref[X]
+  type TL3 = [+X] => Ref[X] // error: covariant type parameter X occurs in nonvariant position in Test.Ref[X]
+  type TL4[-X] = X => X // error: contravariant type parameter X occurs in covariant position in X => X
 
   def f[F <: [+X] => Any](x: F[String]): F[Any] = x