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.

Author: DarkDimius

src/dotty/tools/dotc/transform/MixinOps.scala

@@ -41,11 +41,24 @@ 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 methodsThatJVMwillConsider =
+      cls.baseClasses.flatMap(zuper =>
+        if (zuper ne meth.owner) {
+          val sym = meth.overriddenSymbol(zuper)
+          if (sym.exists) sym :: Nil
+          else Nil
+          //zuper.info.decls.lookupAll(meth.name).filter(sym => (!sym.is(Private) && sym.signature.matchDegree(meth.signature) == Signature.FullMatch))
+        } else Nil
+      )
+    def needsDisambiguation = methodsThatJVMwillConsider.exists(x=> !(x is Deferred)) // multiple implementations are available
+    def hasNonInterfaceDefinition = methodsThatJVMwillConsider.exists(!_.owner.is(Trait)) // there is a definition originating from class
     meth.is(Method, butNot = PrivateOrAccessorOrDeferred) &&
     isCurrent(meth) &&
     (needsDisambiguation || hasNonInterfaceDefinition || meth.owner.is(Scala2x))