Fix #4031: Check arguments of dependent methods for realizability

 - Skolemize if not realizable, but use an approximating map
   that avoids using such skolems as paths (because that would
   be unsound).

Author: odersky

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

@@ -18,6 +18,7 @@ import Denotations._
 import Periods._
 import util.Stats._
 import util.SimpleIdentitySet
+import CheckRealizable.{realizability, Realizable}
 import reporting.diagnostic.Message
 import ast.tpd._
 import ast.TreeTypeMap
@@ -149,14 +150,20 @@ object Types {
 
     /** Does this type denote a stable reference (i.e. singleton type)? */
     final def isStable(implicit ctx: Context): Boolean = stripTypeVar match {
-      case tp: TermRef => tp.termSymbol.isStable && tp.prefix.isStable || tp.info.isStable
+      case tp: TermRef => tp.symbol.isStable && tp.prefix.isStable || tp.info.isStable
       case _: SingletonType | NoPrefix => true
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
       case tp: AnnotatedType => tp.parent.isStable
       case _ => false
     }
 
+    /** Does this type denote a realizable stable reference? Much more expensive to check
+     *  than isStable, that's why some of the checks are done later in PostTyper.
+     */
+    final def isStableRealizable(implicit ctx: Context): Boolean =
+      isStable && realizability(this) == Realizable
+
     /** Is this type a (possibly refined or applied or aliased) type reference
      *  to the given type symbol?
      *  @sym  The symbol to compare to. It must be a class symbol or abstract type.
@@ -3573,6 +3580,17 @@ object Types {
 
     def withName(name: Name): this.type = { myRepr = name; this }
 
+    private[this] var isRealizableKnown = false
+    private[this] var isRealizableCache: Boolean = _
+
+    def isRealizable(implicit ctx: Context) = {
+      if (!isRealizableKnown) {
+        isRealizableCache = realizability(info) == Realizable
+        isRealizableKnown = true
+      }
+      isRealizableCache
+    }
+
     private[this] var myRepr: Name = null
     def repr(implicit ctx: Context): Name = {
       if (myRepr == null) myRepr = SkolemName.fresh()
@@ -4506,6 +4524,8 @@ object Types {
       else if (lo `eq` hi) lo
       else Range(lower(lo), upper(hi))
 
+    protected def emptyRange = range(defn.NothingType, defn.AnyType)
+
     protected def isRange(tp: Type): Boolean = tp.isInstanceOf[Range]
 
     protected def lower(tp: Type): Type = tp match {
@@ -4578,6 +4598,9 @@ object Types {
             else tryWiden(tp, preHi)
           forwarded.orElse(
             range(super.derivedSelect(tp, preLo).loBound, super.derivedSelect(tp, preHi).hiBound))
+        case pre: SkolemType if !pre.isRealizable =>
+          // If `pre` is not realizable it could would be in general unsound to use it as a path
+          emptyRange
         case _ =>
           super.derivedSelect(tp, pre) match {
             case TypeBounds(lo, hi) => range(lo, hi)
@@ -4630,7 +4653,7 @@ object Types {
       else tp.derivedTypeBounds(lo, hi)
 
     override protected def derivedSuperType(tp: SuperType, thistp: Type, supertp: Type): Type =
-      if (isRange(thistp) || isRange(supertp)) range(defn.NothingType, defn.AnyType)
+      if (isRange(thistp) || isRange(supertp)) emptyRange
       else tp.derivedSuperType(thistp, supertp)
 
     override protected def derivedAppliedType(tp: AppliedType, tycon: Type, args: List[Type]): Type =

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

@@ -478,8 +478,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
             addArg(typedArg(arg, formal), formal)
             if (methodType.isParamDependent && typeOfArg(arg).exists)
               // `typeOfArg(arg)` could be missing because the evaluation of `arg` produced type errors
-              safeSubstParam(_, methodType.paramRefs(n), typeOfArg(arg))
-            else identity
+              safeSubstParam(_, methodType.paramRefs(n), typeOfArg(arg), initVariance = -1)
+            else
+              identity
           }
 
           def missingArg(n: Int): Unit = {

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

@@ -105,7 +105,7 @@ trait TypeAssigner {
             case info: ClassInfo =>
               range(defn.NothingType, apply(classBound(info)))
             case _ =>
-              range(defn.NothingType, defn.AnyType) // should happen only in error cases
+              emptyRange // should happen only in error cases
           }
         case tp: ThisType if toAvoid(tp.cls) =>
           range(defn.NothingType, apply(classBound(tp.cls.classInfo)))
@@ -340,13 +340,22 @@ trait TypeAssigner {
     }
   }
 
-  /** Substitute argument type `argType` for parameter `pref` in type `tp`,
+  /** Substitute argument type `argType` for parameter `pref` in type `tp`
    *  skolemizing the argument type if it is not stable and `pref` occurs in `tp`.
+   *  Skolemization has to be done in an approximating type map since the underlying
+   *  type might not be realizable, in which case the skolem cannot be used as a path.
    */
-  def safeSubstParam(tp: Type, pref: ParamRef, argType: Type)(implicit ctx: Context): Type = {
+  def safeSubstParam(tp: Type, pref: ParamRef, argType: Type, initVariance: Int = 1)(implicit ctx: Context): Type = {
     val tp1 = tp.substParam(pref, argType)
-    if ((tp1 eq tp) || argType.isStable) tp1
-    else tp.substParam(pref, SkolemType(argType.widen))
+    if ((tp1 eq tp) || argType.isStableRealizable) tp1
+    else {
+      val avoidParam = new ApproximatingTypeMap {
+        val skolem = SkolemType(argType.widen)
+        variance = initVariance
+        def apply(t: Type) = if (t `eq` pref) skolem else mapOver(t)
+      }
+      avoidParam(tp)
+    }
   }
 
   /** Substitute types of all arguments `args` for corresponding `params` in `tp`.

tests/neg/i4031-posttyper.scala

@@ -0,0 +1,7 @@
+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 coerce2(x: Any): Int = upcast(p, x): p.L // error: not a legal path
+}

tests/neg/i4031.scala

@@ -0,0 +1,26 @@
+// originlly reported in #4031
+object Test {
+  trait A { type L >: Any}
+  def upcast(a: A, x: Any): a.L = x
+  lazy val p: A { type L <: Nothing } = p
+  def coerce(x: Any): Int = upcast(p, x) // error: found Any required: Int
+
+  def main(args: Array[String]): Unit = {
+    println(coerce("Uh oh!"))
+  }
+}
+// variations
+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: found Any required: Int
+   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(p, p) // error: found App.A{L <: Nothing}(App.p) required: Nothing
+    compare2(p)(p) // error: found App.A{L <: Nothing}(App.p) required: App.A{L <: Nothing}(?1)
+  }
+}

tests/neg/i4060.scala

@@ -6,11 +6,11 @@ object App {
     trait X { type R >: U }
     trait Y { type R = V }
 
-    class T[A <: X](erased val a: A)(val value: a.R) // error
+    class T[A <: X](erased val a: A)(val value: a.R)
 
     object O { lazy val x : Y & X = ??? }
 
-    val a = new T[Y & X](O.x)(u)
+    val a = new T[Y & X](O.x)(u)  // error
     a.value
   }
 

tests/neg/i50-volatile.scala

@@ -10,16 +10,23 @@ class Test {
   }
   lazy val o: A & B = ???
 
-  class Client extends o.Inner                          // old-error // old-error
+  class Client extends o.Inner                          // 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/pos/i4031.scala

@@ -0,0 +1,8 @@
+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 coerce1(x: Any): Any = upcast(q, x)  // ok
+  def coerce3(x: Any): Any = upcast(p, x)  // ok, since dependent result type is not needed
+}