Incorporated PR review comments

+ Style tweaks.
+ Meaningful argument name.
+ Added negative test cases.

Author: milessabin

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

@@ -2348,7 +2348,7 @@ class Typer extends Namer
       def dummyArg(tp: Type) = untpd.Ident(nme.???).withTypeUnchecked(tp)
 
       def addImplicitArgs(implicit ctx: Context) = {
-        def implicitArgs(formals: List[Type], n: Int): List[Tree] = formals match {
+        def implicitArgs(formals: List[Type], argIndex: Int): List[Tree] = formals match {
           case Nil => Nil
           case formal :: formals1 =>
             val arg = inferImplicitArg(formal, tree.pos.endPos)
@@ -2366,9 +2366,9 @@ class Typer extends Namer
                 // done for non-implicit parameter lists in Applications#matchArgs#addTyped.
                 val formals2 =
                   if (wtp.isParamDependent && arg.tpe.exists)
-                    formals1 mapconserve {f1 => safeSubstParam(f1, wtp.paramRefs(n), arg.tpe)}
+                    formals1.mapconserve(f1 => safeSubstParam(f1, wtp.paramRefs(argIndex), arg.tpe))
                   else formals1
-                arg :: implicitArgs(formals2, n+1)
+                arg :: implicitArgs(formals2, argIndex + 1)
             }
         }
         val args = implicitArgs(wtp.paramInfos, 0)

tests/neg/t5427.scala

@@ -0,0 +1,26 @@
+trait Foo[In] { type Out }
+
+object Test {
+  def fooInt: Foo[Int] { type Out = String } = ???
+  implicit def str: String = ???
+
+  def test1[A](f1: Foo[A])(implicit f2: f1.Out) = ???
+  def test2[A](implicit f1: Foo[A], f2: f1.Out) = ???
+
+  test1(fooInt)   // OK
+  test2           // error
+}
+
+object Test2 {
+  implicit def fooInt: Foo[Int] { type Out = String } = ???
+  implicit def fooString: Foo[String] { type Out = Boolean } = ???
+  implicit def fooBoolean: Foo[Boolean] { type Out = Double } = ???
+
+  def test3[A](f1: Foo[A], f2: Foo[f1.Out])(implicit f3: Foo[f2.Out]): f3.Out = ???
+  def test4[A](implicit f1: Foo[A], f2: Foo[f1.Out], f3: Foo[f2.Out]): f3.Out = ???
+
+  val t3 = test3(fooInt, fooString)
+  t3: Double
+  val t4 = test4  // error
+  t4: Double
+}