Move generatation of trait bridges to Erasure

Author: WojciechMazur

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

@@ -610,7 +610,6 @@ trait BCodeSkelBuilder extends BCodeHelpers {
               genTraitConstructorDefDef(dd)
             else
               genStaticForwarderForDefDef(dd)
-              genInterfaceMethodBridgeForDefDef(dd)
               genDefDef(dd)
           else
             genDefDef(dd)
@@ -691,48 +690,6 @@ 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)

compiler/src/dotty/tools/dotc/transform/Bridges.scala

@@ -31,10 +31,12 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
 
     /** Only use the superclass of `root` as a parent class. This means
      *  overriding pairs that have a common implementation in a trait parent
-     *  are also counted. This is necessary because we generate bridge methods
-     *  only in classes, never in traits.
+     *  are also counted. The only exception is generation of bridges for traits,
+     *  where we want to be able to deduplicate bridges already defined in parents.
      */
-    override def parents = Array(root.superClass)
+    override lazy val parents =
+      if(root.is(Trait)) super.parents
+      else Array(root.superClass)
 
     override def exclude(sym: Symbol) =
       !sym.isOneOf(MethodOrModule) || sym.isAllOf(Module | JavaDefined) || super.exclude(sym)
@@ -170,9 +172,14 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
    *  time deferred methods in `stats` that are replaced by a bridge with the same signature.
    */
   def add(stats: List[untpd.Tree]): List[untpd.Tree] =
+    // When adding bridges to traits ignore non-public methods
+    // see `DottyBackendTests.invocationReceivers`
     val opc = inContext(preErasureCtx) { new BridgesCursor }
     while opc.hasNext do
-      if !opc.overriding.is(Deferred) then
+      if
+        !opc.overriding.is(Deferred) &&
+        (!root.is(Trait) || opc.overridden.isPublic)
+      then
         addBridgeIfNeeded(opc.overriding, opc.overridden)
       opc.next()
     if bridges.isEmpty then stats

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -1065,5 +1065,5 @@ object Erasure {
   }
 
   private def takesBridges(sym: Symbol)(using Context): Boolean =
-    sym.isClass && !sym.isOneOf(Flags.Trait | Flags.Package)
+    sym.isClass && !sym.is(Flags.Package)
 }

tests/run/mixin-signatures.check

@@ -49,10 +49,9 @@ class Test$bar5$ {
 }
 
 interface Foo1 {
-  public abstract java.lang.Object Base.f(java.lang.Object)
-    generic: public abstract R Base.f(T)
   public default java.lang.String Foo1.f(java.lang.Object)
     generic: public default java.lang.String Foo1.f(T)
+  public default java.lang.Object Foo1.f(java.lang.Object) <bridge> <synthetic>
   public abstract java.lang.Object Base.g(java.lang.Object)
     generic: public abstract R Base.g(T)
   public abstract java.lang.String Foo1.g(java.lang.Object)
@@ -62,10 +61,9 @@ interface Foo1 {
 }
 
 interface Foo2 {
-  public abstract java.lang.Object Base.f(java.lang.Object)
-    generic: public abstract R Base.f(T)
   public default java.lang.Object Foo2.f(java.lang.String)
     generic: public default R Foo2.f(java.lang.String)
+  public default java.lang.Object Foo2.f(java.lang.Object) <bridge> <synthetic>
   public abstract java.lang.Object Base.g(java.lang.Object)
     generic: public abstract R Base.g(T)
   public abstract java.lang.Object Foo2.g(java.lang.String)