Fix a problem in IsFullyDefinedAccumulator

A maximized type variable could be instantiated to a type
that contains more type variables. These have to be instantiated
in turn.

Author: odersky

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

@@ -17,7 +17,7 @@ import reporting.diagnostic.Message
 import config.Printers.{gadts, typr}
 import typer.Applications._
 import typer.ProtoTypes._
-import typer.ForceDegree
+import typer.{ForceDegree, IfBottom}
 import typer.Inferencing.isFullyDefined
 
 import scala.annotation.internal.sharable
@@ -644,7 +644,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       tvar =>
         !(ctx.typerState.constraint.entry(tvar.origin) `eq` tvar.origin.underlying) ||
         (tvar `eq` removeThisType.prefixTVar),
-      allowBottom = false
+      IfBottom.maximize
     )
 
     // If parent contains a reference to an abstract type, then we should

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

@@ -55,7 +55,7 @@ object Inferencing {
   def instantiateSelected(tp: Type, tvars: List[Type])(implicit ctx: Context): Unit =
     if (tvars.nonEmpty)
       IsFullyDefinedAccumulator(
-        ForceDegree.Value(tvars.contains, allowBottom = false), minimizeSelected = true
+        ForceDegree.Value(tvars.contains, IfBottom.maximize), minimizeSelected = true
       ).process(tp)
 
   /** Instantiate any type variables in `tp` whose bounds contain a reference to
@@ -132,7 +132,9 @@ object Inferencing {
             if tvar.hasLowerBound then instantiate(tvar, fromBelow = true)
             else if tvar.hasUpperBound then instantiate(tvar, fromBelow = false)
             else () // hold off instantiating unbounded unconstrained variables
-          else if variance >= 0 && (force.allowBottom || tvar.hasLowerBound) then
+          else if variance >= 0
+                  && (force.ifBottom == IfBottom.ok || tvar.hasLowerBound)
+          then
             instantiate(tvar, fromBelow = true)
           else
             toMaximize = tvar :: toMaximize
@@ -150,9 +152,14 @@ object Inferencing {
           if !tvar.isInstantiated then
             instantiate(tvar, fromBelow = false)
         case nil =>
-      val res = apply(true, tp)
-      if res then maximize(toMaximize)
-      res
+      apply(true, tp)
+      && (
+        toMaximize.isEmpty
+        || { maximize(toMaximize)
+             toMaximize = Nil       // Do another round since the maximixing instances
+             process(tp)            // might have type uninstantiated variables themselves.
+           }
+      )
   }
 
   /** For all type parameters occurring in `tp`:
@@ -508,10 +515,15 @@ trait Inferencing { this: Typer =>
 }
 
 /** An enumeration controlling the degree of forcing in "is-dully-defined" checks. */
-@sharable object ForceDegree {
-  class Value(val appliesTo: TypeVar => Boolean, val allowBottom: Boolean)
-  val none: Value = new Value(_ => false, allowBottom = true)
-  val all: Value = new Value(_ => true, allowBottom = true)
-  val noBottom: Value = new Value(_ => true, allowBottom = false)
-}
+@sharable object ForceDegree:
+  class Value(val appliesTo: TypeVar => Boolean, val ifBottom: IfBottom)
+  val none: Value = new Value(_ => false, ifBottom = IfBottom.ok)
+  val all: Value = new Value(_ => true, ifBottom = IfBottom.ok)
+  val noBottom: Value = new Value(_ => true, ifBottom = IfBottom.maximize)
+
+/** How to react when trying to instantiate a type variable without lower bound */
+enum IfBottom:
+  case ok                      // instantiate to Nothing
+  case maximize                // maximize to upper bound
+  case maximizeUpTo(tp: Type)  // maximize to glb of upper bound and `tp`.
 

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

@@ -1044,20 +1044,18 @@ class Typer extends Namer
       *  type in MT, if this one is fully defined.
       *  If both attempts fail, issue a "missing parameter type" error.
       */
-    def inferredParamType(param: untpd.ValDef, formal: Type): Type = {
-      if (isFullyDefined(formal, ForceDegree.noBottom)) return formal
-      calleeType.widen match {
+    def inferredParamType(param: untpd.ValDef, formal: Type): Type =
+      if isFullyDefined(formal, ForceDegree.noBottom) then return formal
+      val target = calleeType.widen match
         case mtpe: MethodType =>
           val pos = paramIndex(param.name)
-          if (pos < mtpe.paramInfos.length) {
+          if pos < mtpe.paramInfos.length then
             val ptype = mtpe.paramInfos(pos)
-            if (isFullyDefined(ptype, ForceDegree.noBottom) && !ptype.isRepeatedParam)
-              return ptype
-          }
-        case _ =>
-      }
-      errorType(AnonymousFunctionMissingParamType(param, params, tree, formal), param.sourcePos)
-    }
+            if ptype.isRepeatedParam then NoType else ptype
+          else NoType
+        case _ => NoType
+      if target.exists && isFullyDefined(target, ForceDegree.noBottom) then target
+      else errorType(AnonymousFunctionMissingParamType(param, params, tree, formal), param.sourcePos)
 
     def protoFormal(i: Int): Type =
       if (protoFormals.length == params.length) protoFormals(i)