Fix #4031: Check arguments of dependent methods for realizability

Also some additions to realizability tests

Author: odersky

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

@@ -205,6 +205,11 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
               Checking.checkInstantiable(tree.tpe, nu.pos)
               withNoCheckNews(nu :: Nil)(super.transform(tree))
             case _ =>
+              tree.fun.tpe.widen match {
+                case mt: MethodType if mt.isDependent || mt.isParamDependent =>
+                  Checking.checkRealizableArgs(mt, tree.args)
+                case _ =>
+              }
               super.transform(tree)
           }
         case tree: TypeApply =>

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

@@ -151,6 +151,18 @@ object Checking {
       ctx.errorOrMigrationWarning(em"$tp is not a legal path\nsince it${rstatus.msg}", pos)
   }
 
+  /** Check that all arguments to dependent parameters are realizable */
+  def checkRealizableArgs(mt: MethodType, args: List[Tree])(implicit ctx: Context): Unit = {
+    val paramTypes = mt.paramInfos.toArray
+    val resultType = mt.resultType
+    def isDependent(paramRef: ParamRef, i: Int) =
+      (i + 1 until paramTypes.length).exists(j => paramRef.occursIn(paramTypes(j))) ||
+      paramRef.occursIn(resultType)
+    for ((paramRef, i) <- mt.paramRefs.zipWithIndex)
+      if (isDependent(paramRef, i))
+        checkRealizable(args(i).tpe, args(i).pos)
+  }
+
   /** A type map which checks that the only cycles in a type are F-bounds
    *  and that protects all F-bounded references by LazyRefs.
    */

tests/neg/i4031.scala

@@ -0,0 +1,21 @@
+object App {
+  trait A { type L >: Any}
+  def upcast(a: A, x: Any): a.L = x
+  lazy val p: A { type L <: Nothing } = p
+  val q = new A { type L = Any }
+  def coerce(x: Any): Int = upcast(p, x)  // error: not a legal path
+  def coerce1(x: Any): Any = upcast(q, x)  // ok
+  def coerce2(x: Any): Int = upcast(p, x): p.L // error: not a legal path // error
+
+  def compare(x: A, y: x.L) = assert(x == y)
+
+  def compare2(x: A)(y: x.type) = assert(x == y)
+
+
+  def main(args: Array[String]): Unit = {
+    //println(coerce("Uh oh!"))
+    compare(q, q) // OK
+    compare(p, p) // error: not a legal path
+    compare2(p)(p) // error: not a legal path
+  }
+}

tests/neg/i50-volatile.scala

@@ -12,14 +12,21 @@ class Test {
 
   class Client extends o.Inner                          // old-error // old-error
 
-  def xToString(x: o.X): String = x                     // old-error
+  def xToString(x: o.X): String = x                     // error
 
   def intToString(i: Int): String = xToString(i)
 }
-object Test2 {
 
-  import Test.o._                                       // error
+object Test2 {
+  trait A {
+    type X = String
+  }
+  trait B {
+    type X = Int
+  }
+  lazy val o: A & B = ???
 
-  def xToString(x: X): String = x
+  def xToString(x: o.X): String = x       // error
 
+  def intToString(i: Int): String = xToString(i)
 }

tests/neg/realizability.scala

@@ -0,0 +1,22 @@
+class C { type T }
+
+class Test {
+
+  type D <: C
+
+  lazy val a: C = ???
+  final lazy val b: C = ???
+  val c: D = ???
+  final lazy val d: D = ???
+
+  val x1: a.T = ???  // error: not a legal path, since a is lazy & non-final
+  val x2: b.T = ???  // OK, b is lazy but concrete
+  val x3: c.T = ???  // OK, c is abstract but strict
+  val x4: d.T = ???  // error: not a legal path since d is abstract and lazy
+
+  val y1: Singleton = a
+  val y2: Singleton = a
+  val y3: Singleton = a
+  val y4: Singleton = a
+
+}

tests/neg/z1720.scala

@@ -0,0 +1,16 @@
+package test
+
+class Thing {
+  def info: Info[this.type] = InfoRepository.getInfo(this)
+  def info2: Info[this.type] = {
+    def self: this.type = this
+    InfoRepository.getInfo(self) // error: not a legal path
+  }
+}
+
+trait Info[T]
+case class InfoImpl[T](thing: T) extends Info[T]
+
+object InfoRepository {
+  def getInfo(t: Thing): Info[t.type] = InfoImpl(t)
+}

tests/pos/z1720.scala

@@ -3,7 +3,7 @@ package test
 class Thing {
   def info: Info[this.type] = InfoRepository.getInfo(this)
   def info2: Info[this.type] = {
-    def self: this.type = this
+    val self: this.type = this
     InfoRepository.getInfo(self)
   }
 }