Fix #5433: check that the implemented super-accessor is valid

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 had the same bug (but at least in Dotty this is
detected by -Ycheck:all), now fixed based on the logic in this PR by
scala/scala#7641.

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.

Author: smarter

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

@@ -100,10 +100,52 @@ object ResolveSuper {
     val SuperAccessorName(memberName) = acc.name.unexpandedName
     ctx.debuglog(i"starting rebindsuper from $base of ${acc.showLocated}: ${acc.info} in $bcs, name = $memberName")
     while (bcs.nonEmpty && sym == NoSymbol) {
-      val other = bcs.head.info.nonPrivateDecl(memberName)
+      val cur = bcs.head
+      val other = cur.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))
+      if (otherMember.exists) {
+        sym = otherMember.symbol
+        // 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
+        val otherTp = otherMember.asSeenFrom(base.typeRef).info
+        val accTp = acc.asSeenFrom(base.typeRef).info
+        if (!(otherTp <:< accTp)) {
+          val superCall = i"super.$memberName"
+          val accSuperCall = i"super[${acc.owner.name}].$memberName"
+          val resolvedSuperCall = i"super[${cur.name}].$memberName"
+          val overriddenOwnerName = {
+            val overriddenIterator = other.symbol.allOverriddenSymbols
+            if (overriddenIterator.hasNext)
+              overriddenIterator.next.owner.name
+            else
+              "SomeParent"
+          }
+          val overriddenSuperCall = i"super[$overriddenOwnerName].$memberName"
+          ctx.error(
+            hl"""$base cannot be instantiated due to a conflict between its parents when
+                |resolving a super-call:
+                |
+                |1. One of its parent (${acc.owner}) contains a call $superCall in its body.
+                |2. Because ${cur.name} comes before ${acc.owner.name} in the linearization
+                |   order of ${base.name}, and because ${cur.name} overrides $memberName,
+                |   this is resolved as a call to $resolvedSuperCall in ${base.name}.
+                |3. However:
+                |   ${otherTp.widenExpr} (the type of $resolvedSuperCall in ${base.name})
+                |   is not a subtype of
+                |   ${accTp.widenExpr} (the type of $accSuperCall in ${base.name})
+                |
+                |Here are two possible ways to resolve this:
+                |
+                |1. Change the linearization order of ${base.name} such that
+                |   ${acc.owner.name} comes before ${cur.name}.
+                |2. Alternatively, replace $superCall in the body of ${acc.owner} by a
+                |   super-call to a specific parent, e.g. $overriddenSuperCall
+                |""".stripMargin, base.sourcePos)
+        }
+      }
+
       bcs = bcs.tail
     }
     assert(sym.exists)

tests/neg/i5433.check

@@ -0,0 +1,19 @@
+<298..298> in i5433.scala
+class Fail cannot be instantiated due to a conflict between its parents when
+resolving a super-call:
+
+1. One of its parent (trait C) contains a call super.foo in its body.
+2. Because B comes before C in the linearization
+   order of Fail, and because B overrides foo,
+   this is resolved as a call to super[B].foo in Fail.
+3. However:
+   X (the type of super[B].foo in Fail)
+   is not a subtype of
+   Y (the type of super[C].foo in Fail)
+
+Here are two possible ways to resolve this:
+
+1. Change the linearization order of Fail such that
+   C comes before B.
+2. Alternatively, replace super.foo in the body of trait C by a
+   super-call to a specific parent, e.g. super[A].foo

tests/neg/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 // error
+  // Generated `def C$$super$foo: Y = 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)
+  }
+}