Make dependency checks level-independent

Author: odersky

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

@@ -181,6 +181,13 @@ abstract class Constraint extends Showable {
   /** A string showing the `coDeps` and `contraDeps` maps */
   def depsToString(using Context): String
 
+  /** Does the constraint restricted to variables outside `except` depend on `tv`
+   *  in the given direction `co`?
+   *  @param `co`  If true, test whether the constraint would change if the variable is made larger
+   *               otherwise, test whether the constraint would change if the variable is made smaller.
+   */
+  def dependsOn(tv: TypeVar, except: TypeVars, co: Boolean)(using Context): Boolean
+
   /** If the type variable `tv` would be instantiated to a larger type, the
    *  constraint over outer type variables would be narrowed.
    */

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

@@ -249,6 +249,15 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       //.showing(i"outer depends on $tv ${tv.initNestingLevel} with ${tvdeps.toList.map(_.initNestingLevel)}%, % = $result")
   end outerDependsOn
 
+  def dependsOn(tv: TypeVar, except: TypeVars, co: Boolean)(using Context): Boolean =
+    def test(deps: TypeVarDeps, lens: ConstraintLens[List[TypeParamRef]]) =
+      val tvdeps = deps(tv)
+      null != tvdeps && tvdeps.exists(!except.contains(_))
+      || lens(this, tv.origin.binder, tv.origin.paramNum).exists(
+            p => !except.contains(typeVarOfParam(p)))
+        //.showing(i"outer depends on $tv with ${tvdeps.toList}%, % = $result")
+    if co then test(coDeps, upperLens) else test(contraDeps, lowerLens)
+
   def outerDependsCovariantlyOn(tv: TypeVar)(using Context) =
     outerDependsOn(tv, tv.nestingLevel, coDeps, upperLens, SimpleIdentitySet.empty)
 

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

@@ -16,6 +16,7 @@ import reporting._
 import collection.mutable
 
 import scala.annotation.internal.sharable
+import dotty.tools.dotc.util.SimpleIdentitySet
 
 object Inferencing {
 
@@ -619,7 +620,7 @@ trait Inferencing { this: Typer =>
         if state.reporter.hasUnreportedErrors then return tree
 
         def constraint = state.constraint
-        type InstantiateQueue = mutable.ListBuffer[(TypeVar, Boolean)]
+        type InstantiateQueue = mutable.ListBuffer[(TypeVar, Int)]
         val toInstantiate = new InstantiateQueue
         for tvar <- qualifying do
           if !tvar.isInstantiated && constraint.contains(tvar) && tvar.nestingLevel >= ctx.nestingLevel then
@@ -637,18 +638,16 @@ trait Inferencing { this: Typer =>
               // instantiate it in the direction corresponding to the
               // original variable which might be further constrained later.
               // Otherwise, we simply rely on `hasLowerBound`.
-              val name = tvar.origin.paramName
-              val fromBelow =
-                if name.is(AvoidNameKind.UpperBound) then true
-                else if name.is(AvoidNameKind.LowerBound) then false
-                else if constraint.outerDependsCovariantlyOn(tvar) then true
-                else if constraint.outerDependsContravariantlyOn(tvar) then false
-                else tvar.hasLowerBound
-              typr.println(i"interpolate non-occurring $tvar in $state in $tree: $tp, fromBelow = $fromBelow, $constraint")
-              toInstantiate += ((tvar, fromBelow))
+              //val name = tvar.origin.paramName
+              //val fromBelow =
+              //  if name.is(AvoidNameKind.UpperBound) then true
+              //  else if name.is(AvoidNameKind.LowerBound) then false
+              //  else if constraint.outerDependsCovariantlyOn(tvar) then true
+              //  else if constraint.outerDependsContravariantlyOn(tvar) then false
+              //  else tvar.hasLowerBound
+              toInstantiate += ((tvar, 0))
             else if v.intValue != 0 then
-              typr.println(i"interpolate $tvar in $state in $tree: $tp, fromBelow = ${v.intValue == 1}, $constraint")
-              toInstantiate += ((tvar, v.intValue == 1))
+              toInstantiate += ((tvar, v.intValue))
             else comparing(cmp =>
               if !cmp.levelOK(tvar.nestingLevel, ctx.nestingLevel) then
                 // Invariant: The type of a tree whose enclosing scope is level
@@ -689,10 +688,38 @@ trait Inferencing { this: Typer =>
          *      V2 := V3, O2 := O3
          */
         def doInstantiate(buf: InstantiateQueue): Unit =
+          val varsToInstantiate = buf.foldLeft(SimpleIdentitySet.empty: TypeVars) {
+            case (tvs, (tv, _)) => tvs + tv
+          }
           if buf.nonEmpty then
             val suspended = new InstantiateQueue
             while buf.nonEmpty do
-              val first @ (tvar, fromBelow) = buf.head
+              val first @ (tvar, v) = buf.head
+              val fromBelow =
+                if v == 0 then
+                  val aboveOK = !constraint.dependsOn(tvar, varsToInstantiate, co = true)
+                  val belowOK = !constraint.dependsOn(tvar, varsToInstantiate, co = false)
+                  val now =
+                    if aboveOK == belowOK then tvar.hasLowerBound
+                    else belowOK
+/*
+                  val was =
+                    val name = tvar.origin.paramName
+                    val depCo = constraint.outerDependsCovariantlyOn(tvar)
+                    val depContra = constraint.outerDependsContravariantlyOn(tvar)
+                    if name.is(AvoidNameKind.UpperBound) then true
+                    else if name.is(AvoidNameKind.LowerBound) then false
+                    else if constraint.outerDependsCovariantlyOn(tvar) then true
+                    else if constraint.outerDependsContravariantlyOn(tvar) then false
+                    else tvar.hasLowerBound
+                  if now != was then
+                    println(i"diff for $tvar, was $was, aboveOK = $aboveOK, belowOK = $belowOK, depCo = $depCo, depContra = $depContra")
+*/
+                  now
+                else
+                  v == 1
+              typr.println(
+                i"interpolate${if v == 0 then "non-occurring" else ""} $tvar in $state in $tree: $tp, fromBelow = $fromBelow, $constraint")
               buf.dropInPlace(1)
               if !tvar.isInstantiated then
                 val suspend = buf.exists{ (following, _) =>