Check variances of type lambdas after Typer

Author: odersky

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -4,7 +4,7 @@ package transform
 import dotty.tools.dotc.ast.{Trees, tpd, untpd}
 import scala.collection.mutable
 import core._
-import typer.Checking
+import typer.{Checking, VarianceChecker}
 import Types._, Contexts._, Names._, Flags._, DenotTransformers._, Phases._
 import SymDenotations._, StdNames._, Annotations._, Trees._, Scopes._
 import Decorators._
@@ -296,6 +296,9 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           // when trying to typecheck self types which are intersections.
           Checking.checkNonCyclicInherited(tree.tpe, tree.left.tpe :: tree.right.tpe :: Nil, EmptyScope, tree.pos)
           super.transform(tree)
+        case tree: LambdaTypeTree =>
+          VarianceChecker.checkLambda(tree)
+          super.transform(tree)
         case Import(expr, selectors) =>
           val exprTpe = expr.tpe
           val seen = mutable.Set.empty[Name]

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

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

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

@@ -25,38 +25,35 @@ object VarianceChecker {
    *  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 checkLambda(tree: tpd.LambdaTypeTree)(implicit ctx: Context): Unit = 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"
           }
-          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)
-            }
+          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
+      }
+      checkOK.apply(true, tl.resType)
+    case _ =>
   }
 }
 

tests/neg/type-lambdas-posttyper.scala

@@ -0,0 +1,26 @@
+object Test extends App {
+
+  trait Ord[X]
+
+  type TL1 = [X <: Ord[X]] => (X, X)
+
+  class C extends Ord[C]
+
+  type T1 = TL1[Int] // error: Type argument Int does not conform to upper bound Test.Ord[LazyRef(Int)
+  type T2 = TL1[C]   // OK
+
+  class Ref[X](init: X) {
+    var x: X = init
+  }
+
+  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
+
+  val sref = new Ref[String]("abc")
+  val aref: Ref[Any] = f[TL3](sref)
+  aref.x = 1
+  val s: String = sref.x
+
+}

tests/neg/type-lambdas.scala

@@ -5,26 +5,4 @@ object Test extends App {
   type TL1 = [X <: Ord[X]] => (X, X) // OK
   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]
-
-  type T1 = TL1[Int] // will be discovered later
-  type T2 = TL1[C]   // OK
-
-  class Ref[X](init: X) {
-    var x: X = init
-  }
-
-  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
-
-  val sref = new Ref[String]("abc")
-  val aref: Ref[Any] = f[TL3](sref)
-  aref.x = 1
-  val s: String = sref.x
-
-
-
-
 }

tests/pos/polytypes.scala

@@ -1,6 +1,6 @@
 object Test {
 
-  type T = [+X] => (List[X] => List[X])
+  type T = [X] => (List[X] => List[X])
 
   def reverse[X](xs: List[X]): List[X] = ???
 

tests/pos/reference/type-lambdas.scala

@@ -7,6 +7,5 @@ object Test {
   type CTL = [X] => [Y] => (X, Y)
   type T3 = CTL[Int][String]
 
-  type T2[+X <: X => X] = Any
-  class C[+X <: X => Unit]
+  type T2[+X <: X => X] = Any  // OK - variance is not checked in param bounds
 }

tests/pos/seqtype-cycle/Test2.scala

@@ -3,6 +3,6 @@ package object scala {
   type Throwable = java.lang.Throwable
   type IndexOutOfBoundsException = java.lang.IndexOutOfBoundsException
 
-  type Seq[+A] = scala.collection.Seq[A]
+  type Seq[A] = scala.collection.Seq[A]
   val Seq = scala.collection.Seq
 }