Refine hasCommonParent criterion in OverridingPairs

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

@@ -20,6 +20,11 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
 
   private class BridgesCursor(using Context) extends OverridingPairs.Cursor(root) {
 
+    override def isSubParent(parent: Symbol, bc: Symbol)(using Context) =
+      true
+      	// Never consider a bridge if there is a superclass that would contain it
+      	// See run/t2857.scala for a test that would break with a VerifyError otherwise.
+
     /** 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

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

@@ -1,4 +1,5 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package transform
 
 import ast.{Trees, tpd}
@@ -80,6 +81,10 @@ class ElimErasedValueType extends MiniPhase with InfoTransformer { thisPhase =>
   private def checkNoClashes(root: Symbol)(using Context) = {
     val opc = atPhase(thisPhase) {
       new OverridingPairs.Cursor(root) {
+        override def isSubParent(parent: Symbol, bc: Symbol)(using Context) =
+          // Need to compute suparents before erasure to not filter out parents
+          // that are bypassed with different types. See neg/11719a.scala.
+          atPhase(elimRepeatedPhase.next) { super.isSubParent(parent, bc) }
         override def exclude(sym: Symbol) =
           !sym.is(Method) || sym.is(Bridge) || super.exclude(sym)
         override def matches(sym1: Symbol, sym2: Symbol) =

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

@@ -64,11 +64,25 @@ object OverridingPairs {
       decls
     }
 
+    /** Is `parent` a qualified sub-parent of `bc`?
+     *  @pre `parent` is a parent class of `base` and it derives from `bc`.
+     *  @return true if the `bc`-basetype of the parent's type is the same as
+     *               the `bc`-basetype of base. In that case, overriding checks
+     *               relative to `parent` already subsume overriding checks
+     *               relative to `base`. See neg/11719a.scala for where this makes
+     *               a difference.
+     */
+    protected def isSubParent(parent: Symbol, bc: Symbol)(using Context) =
+      bc.typeParams.isEmpty
+      || self.baseType(parent).baseType(bc) == self.baseType(bc)
+
     private val subParents = MutableSymbolMap[BitSet]()
+
     for bc <- base.info.baseClasses do
       var bits = BitSet.empty
       for i <- 0 until parents.length do
-        if parents(i).derivesFrom(bc) then bits += i
+        if parents(i).derivesFrom(bc) && isSubParent(parents(i), bc)
+        then bits += i
       subParents(bc) = bits
 
     private def hasCommonParentAsSubclass(cls1: Symbol, cls2: Symbol): Boolean =

tests/neg/i11130.scala

@@ -9,7 +9,7 @@
   trait PBar extends S[Bar] {
     override type T = Bar
   }
-  class PFooBar extends PBar with PFoo {
+  class PFooBar extends PBar with PFoo { // error
     override type T >: Bar  // error
   }
 

tests/neg/i11719.scala

@@ -0,0 +1,12 @@
+class Base
+class Sub extends Base
+
+trait A[+T] {
+  def get: T = ???
+}
+
+trait B extends A[Base] {
+  override def get: Base = new Base
+}
+
+class C extends B with A[Sub] // error: method get in trait B is not a legal implementation

tests/neg/i11719a.scala

@@ -0,0 +1,19 @@
+class Base
+class Sub extends Base
+
+trait A[+T] {
+  def get(f: T => Boolean): Unit = {}
+}
+
+trait B extends A[Base] {
+  override def get(f: Base => Boolean): Unit = f(new Base)
+}
+
+class C extends B with A[Sub] // error: Name clash between inherited members:
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val c = new C
+    c.get((x: Sub) => true) // ClassCastException: Base cannot be cast to Sub
+  }
+}