Gen bridge for inherited methods with narrowed types.

Author: WojciechMazur

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -610,6 +610,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
               genTraitConstructorDefDef(dd)
             else
               genStaticForwarderForDefDef(dd)
+              genInterfaceMethodBridgeForDefDef(dd)
               genDefDef(dd)
           else
             genDefDef(dd)
@@ -690,6 +691,48 @@ trait BCodeSkelBuilder extends BCodeHelpers {
         ).transform(dd.rhs)
       })
 
+    /** Creates a bridges for interfece inherited and narrowed methods,
+     *  to workaround JVM limitations when using LambdaMetaFactory (see issue #15402)
+     *  Example:
+     *  ```
+     *  trait Foo:
+     *    def self: Foo
+     *
+     *  trait Bar extends Foo:
+     *    def self: Bar = this
+     *    def SAM(x: Any): Any
+     *
+     *  def usage(x: List[Foo]) = x.map(_.self)
+     *  ```
+     * We need to define a bridge in trait Bar `def self: Foo = Bar.this.self`
+     * in order to prevent JVM runtime exceptions. Otherwise at the time of
+     * accessing `_.self` in the SAM instance created based on the `trait Bar`
+     * it will complain about missing implementation of `def self: Foo`.
+     * Javac compiler does exactly the same.
+      */
+    private def genInterfaceMethodBridgeForDefDef(dd: DefDef): Unit =
+      val sym = dd.symbol
+      sym.owner.directlyInheritedTraits
+        .flatMap { parent =>
+          val inheritedSym = parent.info.decl(sym.name)
+          Option.when(
+            inheritedSym.exists &&
+            sym.signature != inheritedSym.signature &&
+            sym.info <:< inheritedSym.info
+          )(inheritedSym.symbol.asTerm)
+        }.distinctBy(_.signature)
+         .foreach(genInterfaceMethodBridge(sym.asTerm, _))
+
+    private def genInterfaceMethodBridge(sym: TermSymbol, inheritedSym: TermSymbol): Unit =
+      assert(sym.name == inheritedSym.name, "Not an override")
+      val owner = sym.owner.asClass
+      val bridgeSym = inheritedSym.copy(owner = owner, flags = sym.flags).asTerm
+      val bridge =  tpd.DefDef(bridgeSym, {paramss =>
+        val params = paramss.head
+         tpd.Apply(tpd.This(owner).select(sym), params)
+        })
+      genDefDef(bridge)
+
     private def genStaticForwarderForDefDef(dd: DefDef): Unit =
       val forwarderDef = makeStaticForwarder(dd)
       genDefDef(forwarderDef)

tests/run/i15402.scala

@@ -0,0 +1,18 @@
+trait Named:
+  def me: Named
+
+trait Foo extends Named:
+  def me: Foo = this
+  def foo(x: Named): Named
+
+trait Foo2 extends Foo
+
+class Names(xs: List[Named]):
+  def mkString = xs.map(_.me).mkString(",")
+
+object Names:
+  def single[T <: Named](t: T): Names = Names(List(t))
+
+@main def Test() =
+  Names.single[Foo](identity).mkString
+  Names.single[Foo2](identity).mkString