Take bindingTree into account before implicit search

Take bindingTree into account when deciding which type variables to
instantiate before an implicit search. The additions to i3945.scala
fail without this change.

Also two other tweaks.

Author: odersky

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

@@ -166,7 +166,7 @@ object Inferencing {
       case Apply(fn, _) => boundVars(fn, acc)
       case TypeApply(fn, targs) =>
         val tvars = targs.tpes.collect {
-          case tvar: TypeVar if !tvar.isInstantiated => tvar
+          case tvar: TypeVar if !tvar.isInstantiated && targs.contains(tvar.bindingTree) => tvar
         }
         boundVars(fn, acc ::: tvars)
       case Select(pre, _) => boundVars(pre, acc)
@@ -399,8 +399,8 @@ trait Inferencing { this: Typer =>
   def uninstBoundVars(tree: Tree)(implicit ctx: Context): List[TypeVar] = {
     val buf = new mutable.ListBuffer[TypeVar]
     tree.foreachSubTree {
-      case arg: TypeTree =>
-        arg.tpe match {
+      case TypeApply(_, args) =>
+        args.tpes.foreach {
           case tv: TypeVar if !tv.isInstantiated && tree.contains(tv.bindingTree) => buf += tv
           case _ =>
         }

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

@@ -1970,7 +1970,7 @@ class Typer extends Namer
       if (!tree.denot.isOverloaded) {
       	// for overloaded trees: resolve overloading before simplifying
         if (tree.isDef) interpolateUndetVars(tree, tree.symbol, pt)
-        else if (!tree.tpe.widen.isInstanceOf[LambdaType]) interpolateUndetVars(tree, NoSymbol, pt)
+        else if (!tree.tpe.widen.isInstanceOf[MethodOrPoly]) interpolateUndetVars(tree, NoSymbol, pt)
         tree.overwriteType(tree.tpe.simplified)
       }
       adaptInterpolated(tree, pt)
@@ -2106,8 +2106,10 @@ class Typer extends Namer
     def adaptNoArgsImplicitMethod(wtp: MethodType): Tree = {
       assert(wtp.isImplicitMethod)
       val tvarsToInstantiate = tvarsInParams(tree)
+      println(i"adaptNoArgsImpl $tvarsToInstantiate%, %, ${ctx.typerState.constraint}")
       wtp.paramInfos.foreach(instantiateSelected(_, tvarsToInstantiate))
       val constr = ctx.typerState.constraint
+      println(i"new constr = $constr")
 
       def dummyArg(tp: Type) = untpd.Ident(nme.???).withTypeUnchecked(tp)
 

tests/pos/i3945.scala

@@ -1,11 +1,19 @@
 object Test {
   def int[A](k: String => A)(s: String)(x: Int): A = ???
 
-  // composing directly: ok in scalac, error in dotc
+  // composing directly: ok in scalac, now also in dotc
   val c: (String => String) => (String) => (Int) => (Int) => String = (int[Int => String](_)).compose(int[String](_))
 
   // 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
   val c2: (String => String) => (String) => (Int) => (Int) => String = q.compose(p)
+
+  class B
+  class C extends B
+  implicit def iC: C => Unit = ???
+
+  // making sure A is not instantiated before implicit search
+  def f[A](k: String => A)(s: String)(x: Int)(implicit y: A => Unit): A = ???
+  val r: (String => C) => (String) => (Int) => B = f
 }