Fix problem with partly uninstantiated dependent functions

If the result type of a dependent function contains a type variable whose bounds
refer to the function's parameters, that type variable has to be instantiated before
the method type is formed. Otherwise, if the type variable is instantiated later
the method result type will refer to the original parameter symbols instead of
the method types ParamRefs.

Author: odersky

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

@@ -49,6 +49,27 @@ object Inferencing {
   def instantiateSelected(tp: Type, tvars: List[Type])(implicit ctx: Context): Unit =
     new IsFullyDefinedAccumulator(new ForceDegree.Value(tvars.contains, minimizeAll = true)).process(tp)
 
+  /** Instantiate any type variables in `tp` whose bounds contain a reference to
+   *  one of the parameters in `tparams` or `vparamss`.
+   */
+  def instantiateDependent(tp: Type, tparams: List[Symbol], vparamss: List[List[Symbol]])(implicit ctx: Context): Unit = {
+    val dependentVars = new TypeAccumulator[Set[TypeVar]] {
+      lazy val params = (vparamss :\ tparams)( _ ::: _)
+      def apply(tvars: Set[TypeVar], tp: Type) = tp match {
+        case tp: TypeVar
+        if !tp.isInstantiated &&
+            ctx.typeComparer.bounds(tp.origin)
+              .namedPartsWith(ref => params.contains(ref.symbol))
+              .nonEmpty =>
+          tvars + tp
+        case _ =>
+          foldOver(tvars, tp)
+      }
+    }
+    val depVars = dependentVars(Set(), tp)
+    if (depVars.nonEmpty) instantiateSelected(tp, depVars.toList)
+  }
+
   /** The accumulator which forces type variables using the policy encoded in `force`
    *  and returns whether the type is fully defined. The direction in which
    *  a type variable is instantiated is determined as follows:

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

@@ -96,12 +96,12 @@ trait NamerContextOps { this: Context =>
     else given
 
   /** if isConstructor, make sure it has one non-implicit parameter list */
-  def normalizeIfConstructor(paramSymss: List[List[Symbol]], isConstructor: Boolean) =
+  def normalizeIfConstructor(termParamss: List[List[Symbol]], isConstructor: Boolean) =
     if (isConstructor &&
-      (paramSymss.isEmpty || paramSymss.head.nonEmpty && (paramSymss.head.head is Implicit)))
-      Nil :: paramSymss
+      (termParamss.isEmpty || termParamss.head.nonEmpty && (termParamss.head.head is Implicit)))
+      Nil :: termParamss
     else
-      paramSymss
+      termParamss
 
   /** The method type corresponding to given parameters and result type */
   def methodType(typeParams: List[Symbol], valueParamss: List[List[Symbol]], resultType: Type, isJava: Boolean = false)(implicit ctx: Context): Type = {
@@ -1149,15 +1149,17 @@ class Namer { typer: Typer =>
 
     vparamss foreach completeParams
     def typeParams = tparams map symbolOfTree
-    val paramSymss = ctx.normalizeIfConstructor(vparamss.nestedMap(symbolOfTree), isConstructor)
-    def wrapMethType(restpe: Type): Type =
-      ctx.methodType(tparams map symbolOfTree, paramSymss, restpe, isJava = ddef.mods is JavaDefined)
+    val termParamss = ctx.normalizeIfConstructor(vparamss.nestedMap(symbolOfTree), isConstructor)
+    def wrapMethType(restpe: Type): Type = {
+      instantiateDependent(restpe, typeParams, termParamss)
+      ctx.methodType(tparams map symbolOfTree, termParamss, restpe, isJava = ddef.mods is JavaDefined)
+    }
     if (isConstructor) {
       // set result type tree to unit, but take the current class as result type of the symbol
       typedAheadType(ddef.tpt, defn.UnitType)
       wrapMethType(ctx.effectiveResultType(sym, typeParams, NoType))
     }
-    else valOrDefDefSig(ddef, sym, typeParams, paramSymss, wrapMethType)
+    else valOrDefDefSig(ddef, sym, typeParams, termParamss, wrapMethType)
   }
 
   def typeDefSig(tdef: TypeDef, sym: Symbol, tparamSyms: List[TypeSymbol])(implicit ctx: Context): Type = {