Fix #5433: use a valid member to implement a super-accessor

Relying on `matchingDenotation` is not enough as demonstrated by
i5433.scala: in `Fail`, `B#foo` matches `C$$super$foo`
but it cannot implement it since `X` is a supertype of `Y`

Note that scalac seems to have the same bug (but at least in Dotty this
is detected by -Ycheck:all).

For reference, here's what the spec says on resolving super accessors:

  A reference super.m refers statically to a method or type m in the
  least proper supertype of the innermost template containing the
  reference. It evaluates to the member m′ in the actual supertype of that
  template which is equal to m or which overrides m.

This seems like it should be clarified to indicate that the member m'
may be found not only in "the actual supertype" (defined elsewhere) but
in any supertype of the actual supertype.

Author: smarter

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

@@ -103,7 +103,13 @@ object ResolveSuper {
       val other = bcs.head.info.nonPrivateDecl(memberName)
       if (ctx.settings.Ydebug.value)
         ctx.log(i"rebindsuper ${bcs.head} $other deferred = ${other.symbol.is(Deferred)}")
-      sym = other.matchingDenotation(base.thisType, base.thisType.memberInfo(acc)).symbol
+      val otherMember = other.matchingDenotation(base.thisType, base.thisType.memberInfo(acc))
+
+      // Having a matching denotation is not enough: it should also be a subtype
+      // of the superaccessor's type, see i5433.scala for an example where this matters
+      if (otherMember.asSeenFrom(base.typeRef).info <:< acc.asSeenFrom(base.typeRef).info)
+        sym = otherMember.symbol
+
       bcs = bcs.tail
     }
     assert(sym.exists)

tests/run/i5433.scala

@@ -0,0 +1,25 @@
+class X
+class Y extends X
+
+trait A[+T] {
+  def foo: T = null.asInstanceOf[T]
+}
+
+trait B extends A[X] {
+  override def foo: X = new X
+}
+
+trait C extends A[Y] {
+  override def foo: Y = new Y
+  def superFoo: Y = super.foo // C will have an abstract `def C$$super$foo: Y` because of this call
+}
+
+class Fail extends B with C
+  // Should generate `def C$$super$foo: Y = super[A].foo` and not `= super[B].foo`
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val y: Y = (new Fail).superFoo // Used to fail with a ClassCastException because of `Fail#C$$super$foo` being incorrect above
+    assert(y == null)
+  }
+}