Widen variable binders when eta expanding

Author: odersky

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

@@ -3277,7 +3277,7 @@ object Types {
    *  `owningTree` and `owner` are used to determine whether a type-variable can be instantiated
    *  at some given point. See `Inferencing#interpolateUndetVars`.
    */
-  final class TypeVar(val origin: TypeParamRef, creatorState: TyperState, val bindingTree: untpd.Tree, val owner: Symbol) extends CachedProxyType with ValueType {
+  final class TypeVar(val origin: TypeParamRef, creatorState: TyperState, var bindingTree: untpd.Tree, val owner: Symbol) extends CachedProxyType with ValueType {
 
     /** The permanent instance type of the variable, or NoType is none is given yet */
     private[this] var myInst: Type = NoType

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

@@ -192,6 +192,8 @@ object EtaExpansion extends LiftImpure {
    *  more options open.
    *
    *  In each case, the result is an untyped tree, with `es` and `expr` as typed splices.
+   *
+   *    F[V](x) ==> (x => F[X])
    */
   def etaExpand(tree: Tree, mt: MethodType, xarity: Int)(implicit ctx: Context): untpd.Tree = {
     import untpd._

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

@@ -394,6 +394,20 @@ trait Inferencing { this: Typer =>
     }
     if (constraint.uninstVars exists qualifies) interpolate()
   }
+
+  /** The uninstantiated type variables introduced somehwere in `tree` */
+  def uninstBoundVars(tree: Tree)(implicit ctx: Context): List[TypeVar] = {
+    val buf = new mutable.ListBuffer[TypeVar]
+    tree.foreachSubTree {
+      case arg: TypeTree =>
+        arg.tpe match {
+          case tv: TypeVar if !tv.isInstantiated && tree.contains(tv.bindingTree) => buf += tv
+          case _ =>
+        }
+      case _ =>
+    }
+    buf.toList
+  }
 }
 
 /** An enumeration controlling the degree of forcing in "is-dully-defined" checks. */

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

@@ -2242,8 +2242,18 @@ class Typer extends Namer
       if (arity >= 0 &&
           !tree.symbol.isConstructor &&
           !ctx.mode.is(Mode.Pattern) &&
-          !(isSyntheticApply(tree) && !isExpandableApply))
-        typed(etaExpand(tree, wtp, arity), pt)
+          !(isSyntheticApply(tree) && !isExpandableApply)) {
+        // Eta expansion interacts in tricky ways with type variable instantiation
+        // because it can extend the region where type variables are bound (and therefore may not
+        // be interpolated). To avoid premature interpolations, we need to extend the
+        // bindingTree of variables as we go along. Test case in pos/i3945.scala.
+        val boundtvs = uninstBoundVars(tree)
+        val uexpanded = etaExpand(tree, wtp, arity)
+        boundtvs.foreach(_.bindingTree = uexpanded) // make boundtvs point to uexpanded so that they are _not_ interpolated
+        val texpanded = typedUnadapted(uexpanded, pt)
+        boundtvs.foreach(_.bindingTree = texpanded) // make boundtvs point to texpanded so that they _can_ be interpolated
+        adapt(texpanded, pt)
+      }
       else if (wtp.paramInfos.isEmpty && isAutoApplied(tree.symbol))
         adaptInterpolated(tpd.Apply(tree, Nil), pt)
       else if (wtp.isImplicitMethod)

tests/pos/i3945.scala

@@ -6,6 +6,6 @@ object Test {
 
   // unwrapping composition: ok in scalac, ok in dotc
   val q: (String => Int => String) => (String) => (Int) => (Int => String) = int[Int => String]
-  val p: (String => String) => (String) => (Int) => String = int[String]
+  val p: (String => String) => (String) => (Int) => String = int
   val c2: (String => String) => (String) => (Int) => (Int) => String = q.compose(p)
 }