Merge pull request scala#5377 from lrytz/sd143-relax

SD-143 allow super calls to methods defined in indirect super classes

Author: adriaanm

src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala

@@ -152,11 +152,17 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
         // SD-143: a call super[T].m that resolves to A.m cannot be translated to correct bytecode if
         //   - A is a class (not a trait / interface), but not the direct superclass. Invokespecial
         //     would select an overriding method in the direct superclass, rather than A.m.
+        //     We allow this if there are statically no intervening overrides.
         //     https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.invokespecial
         //   - A is a java-defined interface and not listed as direct parent of the class. In this
         //     case, `invokespecial A.m` would be invalid.
+        def hasClassOverride(member: Symbol, subclass: Symbol): Boolean = {
+          if (subclass == ObjectClass || subclass == member.owner) false
+          else if (member.overridingSymbol(subclass) != NoSymbol) true
+          else hasClassOverride(member, subclass.superClass)
+        }
         val owner = sym.owner
-        if (!owner.isTrait && owner != clazz.superClass) {
+        if (!owner.isTrait && owner != clazz.superClass && hasClassOverride(sym, clazz.superClass)) {
           reporter.error(sel.pos,
             s"cannot emit super call: the selected $sym is declared in $owner, which is not the direct superclass of $clazz.\n" +
             s"An unqualified super call (super.${sym.name}) would be allowed.")

test/junit/scala/lang/traits/BytecodeTest.scala

@@ -276,6 +276,29 @@ class BytecodeTest extends BytecodeTesting {
     assert(cls.isEmpty, cls.map(_.name))
   }
 
+  @Test
+  def sd143c(): Unit = {
+    // Allow super calls to class methods of indirect super classes
+    val code =
+      """class A { def f = 1 }
+        |class B extends A
+        |trait T extends A { override def f = 2 }
+        |class C extends B with T {
+        |  def t1 = super[B].f
+        |  def t2 = super.f
+        |  def t3 = super[T].f
+        |}
+      """.stripMargin
+    val List(_, _, c, _) = compileClasses(code)
+    val t1 = getInstructions(c, "t1")
+    assert(t1 contains Invoke(INVOKESPECIAL, "A", "f", "()I", false), t1.stringLines)
+    val t2 = getInstructions(c, "t2")
+    val invStat = Invoke(INVOKESTATIC, "T", "f$", "(LT;)I", true)
+    assert(t2 contains invStat, t2.stringLines)
+    val t3 = getInstructions(c, "t3")
+    assert(t3 contains invStat, t3.stringLines)
+  }
+
   @Test
   def sd210(): Unit = {
     val forwardersCompiler = newCompiler(extraArgs = "-Xmixin-force-forwarders:true")