Merge pull request #4835 from Medowhill/issue4725

Fix #4725: Expand implicit method to implicit func

Author: odersky

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

@@ -208,14 +208,18 @@ object EtaExpansion extends LiftImpure {
     val paramTypes: List[Tree] =
       if (isLastApplication && mt.paramInfos.length == xarity) mt.paramInfos map (_ => TypeTree())
       else mt.paramInfos map TypeTree
+    var paramFlag = Synthetic | Param
+    if (mt.isImplicitMethod) paramFlag |= Implicit
     val params = (mt.paramNames, paramTypes).zipped.map((name, tpe) =>
-      ValDef(name, tpe, EmptyTree).withFlags(Synthetic | Param).withPos(tree.pos.startPos))
+      ValDef(name, tpe, EmptyTree).withFlags(paramFlag).withPos(tree.pos.startPos))
     var ids: List[Tree] = mt.paramNames map (name => Ident(name).withPos(tree.pos.startPos))
     if (mt.paramInfos.nonEmpty && mt.paramInfos.last.isRepeatedParam)
       ids = ids.init :+ repeated(ids.last)
     var body: Tree = Apply(lifted, ids)
     if (!isLastApplication) body = PostfixOp(body, Ident(nme.WILDCARD))
-    val fn = untpd.Function(params, body)
+    val fn =
+      if (mt.isImplicitMethod) new untpd.FunctionWithMods(params, body, Modifiers(Implicit))
+      else untpd.Function(params, body)
     if (defs.nonEmpty) untpd.Block(defs.toList map (untpd.TypedSplice(_)), fn) else fn
   }
 }

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

@@ -2355,6 +2355,7 @@ class Typer extends Namer
           !untpd.isImplicitClosure(tree) &&
           !isApplyProto(pt) &&
           !ctx.mode.is(Mode.Pattern) &&
+          !ctx.mode.is(Mode.ImplicitShadowing) &&
           !ctx.isAfterTyper) {
         typr.println(i"insert apply on implicit $tree")
         typed(untpd.Select(untpd.TypedSplice(tree), nme.apply), pt, locked)

tests/pos/i4725.scala

@@ -0,0 +1,18 @@
+object Test1 {
+  trait T[A]
+
+  def foo[S[_], A](implicit ev: implicit T[A] => T[S[A]]): Unit = ()
+  implicit def bar[A : T]: T[List[A]] = ???
+
+  foo[List, Int]
+}
+
+object Test2 {
+  trait T
+  trait S
+
+  def foo(implicit ev: implicit T => S): Unit = ()
+  implicit def bar(implicit ev: T): S = ???
+
+  foo
+}