Experiment: forced instantiation only uses non-param bound

Type variable are normally either instantiated to their lower bound (after some
widening in `widenInferred`) or upper bound. This commit changes this behavior
when the type variable instantiation is forced (which happens in particular
before doing an implicit search, but also when typing the parameters of a
lambda). We now use the "nonParam" bound instead where other type parameters
have been stripped. For example in i16328.scala, when typing

    id(fromParam((x: Base) => x))

we end up with

    id[?S](getParamType[?T]((x: Int) => x))

where
    ?T <: ?S
    ?T <: Base

Before this commit, ?T was then instantiated to ?S & Base (via
Typer#adaptNoArgsImplicitMethod#instantiate), which lead
to an implicit search failure since ?S was left unconstrained.

With this commit, we instead instantiate ?T to its non-param bound `Base`
and propagate this to `?S` itself:

   ?T := Base
   ?S >: Base

The idea is that this leads to constraints being propagated in a more intuitive
way (?S will now be instantiated to Base rather than Nothing or Any), however
this also means that we're adding a whole new way of instantiating type
variables for a seemingly limited number of usecases (see also the discussion
starting at
scala#16328 (comment)).

It's not clear if this won't end up breaking as many things as it fixes, and it
would increase our maintenance burden, so I recommend holding off on this change
for now.

Author: smarter

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

@@ -542,12 +542,16 @@ trait ConstraintHandling {
    *  @return the instantiating type
    *  @pre `param` is in the constraint's domain.
    */
-  final def approximation(param: TypeParamRef, fromBelow: Boolean, maxLevel: Int)(using Context): Type =
+  final def approximation(param: TypeParamRef, fromBelow: Boolean, maxLevel: Int, nonParam: Boolean = false)(using Context): Type =
     constraint.entry(param) match
       case entry: TypeBounds =>
         val useLowerBound = fromBelow || param.occursIn(entry.hi)
         val rawInst = withUntrustedBounds(
-          if useLowerBound then fullLowerBound(param) else fullUpperBound(param))
+          if nonParam then
+            val bounds = nonParamBounds(param)
+            if useLowerBound then bounds.lo else bounds.hi
+          else
+            if useLowerBound then fullLowerBound(param) else fullUpperBound(param))
         val levelInst = fixLevels(rawInst, fromBelow, maxLevel, param)
         if levelInst ne rawInst then
           typr.println(i"level avoid for $maxLevel: $rawInst --> $levelInst")
@@ -701,8 +705,8 @@ trait ConstraintHandling {
    *  The instance type is not allowed to contain references to types nested deeper
    *  than `maxLevel`.
    */
-  def instanceType(param: TypeParamRef, fromBelow: Boolean, widenUnions: Boolean, maxLevel: Int)(using Context): Type = {
-    val approx = approximation(param, fromBelow, maxLevel).simplified
+  def instanceType(param: TypeParamRef, fromBelow: Boolean, widenUnions: Boolean, maxLevel: Int, nonParam: Boolean = false)(using Context): Type = {
+    val approx = approximation(param, fromBelow, maxLevel, nonParam).simplified
     if fromBelow then
       val widened = widenInferred(approx, param, widenUnions)
       // Widening can add extra constraints, in particular the widened type might
@@ -712,7 +716,7 @@ trait ConstraintHandling {
       // (we do not check for non-toplevel occurences: those should never occur
       // since `addOneBound` disallows recursive lower bounds).
       if constraint.occursAtToplevel(param, widened) then
-        instanceType(param, fromBelow, widenUnions, maxLevel)
+        instanceType(param, fromBelow, widenUnions, maxLevel, nonParam)
       else
         widened
     else

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

@@ -2990,15 +2990,20 @@ object TypeComparer {
   def subtypeCheckInProgress(using Context): Boolean =
     comparing(_.subtypeCheckInProgress)
 
-  def instanceType(param: TypeParamRef, fromBelow: Boolean, widenUnions: Boolean, maxLevel: Int = Int.MaxValue)(using Context): Type =
-    comparing(_.instanceType(param, fromBelow, widenUnions, maxLevel))
+  def instanceType(param: TypeParamRef, fromBelow: Boolean,
+    widenUnions: Boolean, maxLevel: Int = Int.MaxValue, nonParam: Boolean = false)(using Context): Type =
+    comparing(_.instanceType(param, fromBelow, widenUnions, maxLevel, nonParam))
 
-  def approximation(param: TypeParamRef, fromBelow: Boolean, maxLevel: Int = Int.MaxValue)(using Context): Type =
-    comparing(_.approximation(param, fromBelow, maxLevel))
+  def approximation(param: TypeParamRef, fromBelow: Boolean,
+    maxLevel: Int = Int.MaxValue, nonParam: Boolean = false)(using Context): Type =
+    comparing(_.approximation(param, fromBelow, maxLevel, nonParam))
 
   def bounds(param: TypeParamRef)(using Context): TypeBounds =
     comparing(_.bounds(param))
 
+  def nonParamBounds(param: TypeParamRef)(using Context): TypeBounds =
+    comparing(_.nonParamBounds(param))
+
   def fullBounds(param: TypeParamRef)(using Context): TypeBounds =
     comparing(_.fullBounds(param))
 

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

@@ -4755,12 +4755,19 @@ object Types {
      *  instantiation can be a singleton type only if the upper bound
      *  is also a singleton type.
      */
-    def instantiate(fromBelow: Boolean)(using Context): Type =
-      val tp = TypeComparer.instanceType(origin, fromBelow, widenUnions, nestingLevel)
+    def instantiate(fromBelow: Boolean, nonParam: Boolean = false)(using Context): Type =
+      val tp = TypeComparer.instanceType(origin, fromBelow, widenUnions, nestingLevel, nonParam)
       if myInst.exists then // The line above might have triggered instantiation of the current type variable
         myInst
       else
-        instantiateWith(tp)
+        if nonParam then
+          if this =:= tp then
+            instantiateWith(tp)
+          else
+            // fallback if instantiating to the non-param bound failed, should only happen in case of errors?
+            instantiate(fromBelow, nonParam = false)
+        else
+          instantiateWith(tp)
 
     /** Widen unions when instantiating this variable in the current context? */
     def widenUnions(using Context): Boolean = !ctx.typerState.constraint.isHard(this)

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

@@ -163,7 +163,7 @@ object Inferencing {
     (using Context) extends TypeAccumulator[Boolean] {
 
     private def instantiate(tvar: TypeVar, fromBelow: Boolean): Type = {
-      val inst = tvar.instantiate(fromBelow)
+      val inst = tvar.instantiate(fromBelow, nonParam = true)
       typr.println(i"forced instantiation of ${tvar.origin} = $inst")
       inst
     }
@@ -367,15 +367,40 @@ object Inferencing {
     occurring(tree, boundVars(tree, Nil), Nil)
   }
 
+  //TODO: duplication with OrderingConstraint#stripParams
+  private def stripParams(tp: Type, isUpper: Boolean)(using Context): Type = tp match
+    case param: TypeParamRef if ctx.typerState.constraint.contains(param) =>
+      NoType
+    case tp: TypeBounds =>
+      val lo1 = stripParams(tp.lo, !isUpper).orElse(defn.NothingType)
+      val hi1 = stripParams(tp.hi, isUpper).orElse(tp.topType)
+      tp.derivedTypeBounds(lo1, hi1)
+    case tp: AndType if isUpper =>
+      val tp1 = stripParams(tp.tp1, isUpper)
+      val tp2 = stripParams(tp.tp2, isUpper)
+      if (tp1.exists)
+        if (tp2.exists) tp.derivedAndType(tp1, tp2)
+        else tp1
+      else tp2
+    case tp: OrType if !isUpper =>
+      val tp1 = stripParams(tp.tp1, isUpper)
+      val tp2 = stripParams(tp.tp2, isUpper)
+      if (tp1.exists)
+        if (tp2.exists) tp.derivedOrType(tp1, tp2)
+        else tp1
+      else tp2
+    case _ =>
+      tp
+
   /** The instantiation direction for given poly param computed
    *  from the constraint:
    *  @return   1 (maximize) if constraint is uniformly from above,
    *           -1 (minimize) if constraint is uniformly from below,
    *            0 if unconstrained, or constraint is from below and above.
    */
   private def instDirection(param: TypeParamRef)(using Context): Int = {
-    val constrained = TypeComparer.fullBounds(param)
-    val original = param.binder.paramInfos(param.paramNum)
+    val constrained = TypeComparer.nonParamBounds(param)
+    val original = stripParams(param.binder.paramInfos(param.paramNum), isUpper = true).asInstanceOf[TypeBounds]
     val cmp = TypeComparer
     val approxBelow =
       if (!cmp.isSubTypeWhenFrozen(constrained.lo, original.lo)) 1 else 0

tests/pos/i16328.scala

@@ -0,0 +1,20 @@
+trait Base
+trait Sub extends Base
+
+trait Foo[T]:
+  val x: T
+object Foo:
+  given Foo[Base] with
+    val x: Base = new Base {}
+  given Foo[Sub] with
+    val x: Sub = new Sub {}
+
+class Test:
+  def fromParam[T](x: T => Any)(using foo: Foo[T]): T = foo.x
+
+  def id[S](x: S): S = x
+
+  def test =
+    fromParam((x: Base) => x) // ok before
+    id(fromParam((x: Base) => x)) // ok now (before: ambiguous given for Foo[Base & S])
+    id(id(fromParam((x: Base) => x))) // ok now (before: ambiguous given for Foo[Base & S])