Erasure: Don't generate forwarders to abstract members.

Those forwarders may disrupt method resolution.

Author: DarkDimius

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

@@ -614,38 +614,44 @@ object Erasure extends TypeTestsCasts{
                   val newSymbol = member.symbol(ctx)
                   assert(oldSymbol.name(beforeCtx) == newSymbol.name,
                     s"${oldSymbol.name(beforeCtx)} bridging with ${newSymbol.name}")
-                  val newOverridden = oldSymbol.denot.allOverriddenSymbols.toSet // TODO: clarify new <-> old in a comment; symbols are swapped here
-                  val oldOverridden = newSymbol.allOverriddenSymbols(beforeCtx).toSet // TODO: can we find a more efficient impl? newOverridden does not have to be a set!
-                  def stillInBaseClass(sym: Symbol) = ctx.owner derivesFrom sym.owner
-                  val neededBridges = (oldOverridden -- newOverridden).filter(stillInBaseClass)
-
-                  var minimalSet = Set[Symbol]()
-                  // compute minimal set of bridges that are needed:
-                  for (bridge <- neededBridges) {
-                    val isRequired = minimalSet.forall(nxtBridge => !(bridge.info =:= nxtBridge.info))
-
-                    if (isRequired) {
-                      // check for clashes
-                      val clash: Option[Symbol] = oldSymbol.owner.info.decls.lookupAll(bridge.name).find {
-                        sym =>
-                          (sym.name eq bridge.name) && sym.info.widen =:= bridge.info.widen
-                      }.orElse(
-                        emittedBridges.find(stat => (stat.name == bridge.name) && stat.tpe.widen =:= bridge.info.widen)
-                          .map(_.symbol))
-                      clash match {
-                        case Some(cl) =>
-                          ctx.error(i"bridge for method ${newSymbol.showLocated(beforeCtx)} of type ${newSymbol.info(beforeCtx)}\n" +
-                            i"clashes with ${cl.symbol.showLocated(beforeCtx)} of type ${cl.symbol.info(beforeCtx)}\n" +
-                            i"both have same type after erasure: ${bridge.symbol.info}")
-                        case None => minimalSet += bridge
+                  if (!oldMember.symbol.is(Flags.Deferred)) {
+                    val newOverridden = oldSymbol.denot.allOverriddenSymbols.toSet
+                    // TODO: clarify new <-> old in a comment; symbols are swapped here
+                    val oldOverridden = newSymbol.allOverriddenSymbols(beforeCtx).toSet
+
+                    // TODO: can we find a more efficient impl? newOverridden does not have to be a set!
+                    def stillInBaseClass(sym: Symbol) = ctx.owner derivesFrom sym.owner
+
+                    val neededBridges = (oldOverridden -- newOverridden).filter(stillInBaseClass)
+
+                    var minimalSet = Set[Symbol]()
+                    // compute minimal set of bridges that are needed:
+                    for (bridge <- neededBridges) {
+                      val isRequired = minimalSet.forall(nxtBridge => !(bridge.info =:= nxtBridge.info))
+
+                      if (isRequired) {
+                        // check for clashes
+                        val clash: Option[Symbol] = oldSymbol.owner.info.decls.lookupAll(bridge.name).find {
+                          sym =>
+                            (sym.name eq bridge.name) && sym.info.widen =:= bridge.info.widen
+                        }.orElse(
+                          emittedBridges.find(stat => (stat.name == bridge.name) && stat.tpe.widen =:= bridge.info.widen)
+                            .map(_.symbol))
+                        clash match {
+                          case Some(cl) =>
+                            ctx.error(i"bridge for method ${newSymbol.showLocated(beforeCtx)} of type ${newSymbol.info(beforeCtx)}\n" +
+                              i"clashes with ${cl.symbol.showLocated(beforeCtx)} of type ${cl.symbol.info(beforeCtx)}\n" +
+                              i"both have same type after erasure: ${bridge.symbol.info}")
+                          case None => minimalSet += bridge
+                        }
                       }
                     }
-                  }
 
-                  val bridgeImplementations = minimalSet.map {
-                    sym => makeBridgeDef(member, sym)(ctx)
+                    val bridgeImplementations = minimalSet.map {
+                      sym => makeBridgeDef(member, sym)(ctx)
+                    }
+                    emittedBridges ++= bridgeImplementations
                   }
-                  emittedBridges ++= bridgeImplementations
                 } catch {
                   case ex: MergeError => ctx.error(ex.getMessage, member.pos)
                 }

tests/run/i2337.scala

@@ -0,0 +1,34 @@
+/* 
+Minimized from collection strawman 
+This issue has a lot to do with both mixin and bridge generation and subtleties in JVM spec
+if something breaks in this test, this is not a minor issue. Be careful. Here be dragons.
+*/
+
+trait Define[A] {
+  protected def coll: Define[A]
+  def s = coll
+}
+
+trait Iterable[A] extends Define[A] {
+  protected def coll: this.type = this
+}
+
+trait Seq[A] extends Iterable[A]
+
+trait Super1[A] {
+  protected def coll: Iterable[A]
+}
+
+trait Super2[A] extends Super1[A] {
+  override protected def coll: Seq[A]
+}
+
+class Foo[T] extends Seq[T] with Super2[T] {
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val foo = new Foo[Int]
+    foo.s
+  }
+}