Mixin: create less forwarders.

There were two sources of inefficiency in previous scheme:
 - if symbol was no overriding anything the forwarder was still being
created
 - the class that is will have the forwarder was not considered.
Many methods do not require forwarders as JVM will dispatch correctly.

1 files changed, 14 insertions, 4 deletions

diff --git a/src/dotty/tools/dotc/transform/MixinOps.scala b/src/dotty/tools/dotc/transform/MixinOps.scala
index db89f939b..6cebf7197 100644
--- a/src/dotty/tools/dotc/transform/MixinOps.scala
+++ b/src/dotty/tools/dotc/transform/MixinOps.scala
@@ -41,11 +41,21 @@ class MixinOps(cls: ClassSymbol, thisTransform: DenotTransformer)(implicit ctx:
     ctx.atPhase(thisTransform) { implicit ctx =>
       cls.info.member(sym.name).hasAltWith(_.symbol == sym)
     }
-    
+
+  /** Does `method` need a forwarder to in  class `cls`
+   *  Method needs a forwarder in those cases:
+   *   - there's a class defining a method with same signature
+   *   - there are multiple traits defining method with same signature
+   */
   def needsForwarder(meth: Symbol): Boolean = {
-    lazy val overridenSymbols = meth.allOverriddenSymbols
-    def needsDisambiguation = !overridenSymbols.forall(_ is Deferred)
-    def hasNonInterfaceDefinition = overridenSymbols.forall(!_.owner.is(Trait))
+    lazy val competingMethods = cls.baseClasses.iterator
+      .filter(_ ne meth.owner)
+      .map(meth.overriddenSymbol)
+      .filter(_.exists)
+      .toList
+
+    def needsDisambiguation = competingMethods.exists(x=> !(x is Deferred)) // multiple implementations are available
+    def hasNonInterfaceDefinition = competingMethods.exists(!_.owner.is(Trait)) // there is a definition originating from class
     meth.is(Method, butNot = PrivateOrAccessorOrDeferred) &&
     isCurrent(meth) &&
     (needsDisambiguation || hasNonInterfaceDefinition || meth.owner.is(Scala2x))