ResolveSuper: add missing methods overrides for disambiguation

In mixin-overrides.scala, when we compute the overrides for QInt in
ResolveSuper, we need to add an override for Baz#op because it overrides
the concrete method Bar#op (otherwise we'll get a "Conflicting default
methods" error at runtime). Before this commit, this did not happen
because Baz#op was not considered to match Bar#op, because one refers to
Baz.this.A and the other to Bar.thiz.A.

We fix this by calling `matchingDenotation` with a `targetType`
corresponding to the current class (`QInt` here) instead of each base
class where the denotation is defined.

Author: smarter

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -1125,10 +1125,10 @@ object SymDenotations {
     final def memberCanMatchInheritedSymbols(implicit ctx: Context): Boolean =
       !isConstructor && !is(Private)
 
-    /** The symbol, in class `inClass`, that is overridden by this denotation. */
-    final def overriddenSymbol(inClass: ClassSymbol)(implicit ctx: Context): Symbol =
+    /** The symbol, in class `inClass`, that is overridden by this denotation in class `siteClass`.*/
+    final def overriddenSymbol(inClass: ClassSymbol, siteClass: ClassSymbol = owner.asClass)(implicit ctx: Context): Symbol =
       if (!canMatchInheritedSymbols && (owner ne inClass)) NoSymbol
-      else matchingDecl(inClass, owner.thisType)
+      else matchingDecl(inClass, siteClass.thisType)
 
     /** All symbols overridden by this denotation. */
     final def allOverriddenSymbols(implicit ctx: Context): Iterator[Symbol] =
@@ -1142,7 +1142,7 @@ object SymDenotations {
 
     private def overriddenFromType(tp: Type)(implicit ctx: Context): Iterator[Symbol] =
       tp.baseClasses match {
-        case _ :: inherited => inherited.iterator map overriddenSymbol filter (_.exists)
+        case _ :: inherited => inherited.iterator.map(overriddenSymbol(_)).filter(_.exists)
         case Nil => Iterator.empty
       }
 

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

@@ -104,7 +104,7 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
   private def competingMethodsIterator(meth: Symbol): Iterator[Symbol] = {
     cls.baseClasses.iterator
       .filter(_ ne meth.owner)
-      .map(meth.overriddenSymbol)
+      .map(base => meth.overriddenSymbol(base, cls))
       .filter(_.exists)
   }
 }

tests/run/mixin-overrides.scala

@@ -0,0 +1,19 @@
+trait Foo[A] {
+  def op(x: A): Int
+}
+trait Bar[A] extends Foo[A] {
+  override def op(x: A): Int = 1
+}
+trait Baz[A] extends Foo[A] {
+  override def op(x: A): Int = 2
+}
+trait Qux[A] extends Bar[A] with Baz[A]
+
+class QInt extends Qux[Int]
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val qint = new QInt
+    assert(qint.op(1) == 2) // Used to fail with java.lang.IncompatibleClassChangeError: Conflicting default methods: Bar.op Baz.op
+  }
+}