Avoid generation of protected accessors in binary API

Author: nicolasstucki

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

@@ -37,7 +37,7 @@ object ProtectedAccessors {
    *  is not in a subclass or subtrait of `sym`?
    */
   def needsAccessorIfNotInSubclass(sym: Symbol)(using Context): Boolean =
-    sym.isTerm && sym.is(Protected) &&
+    sym.isTerm && sym.is(Protected) && !sym.hasPublicInBinary &&
     !sym.owner.is(Trait) && // trait methods need to be handled specially, are currently always public
     !insideBoundaryOf(sym)
 

compiler/test/dotty/tools/backend/jvm/PublicInBinaryTests.scala

@@ -345,4 +345,44 @@ class PublicInBinaryTests extends DottyBytecodeTest {
         Invoke(INVOKEVIRTUAL, "foo/D$", "bazImpl", "()V", false)))
     }
   }
+
+  @Test
+  def noProtectedAccessorsForBinaryInPublic(): Unit = {
+    val code =
+      """import scala.annotation.publicInBinary
+        |package p {
+        |  class A {
+        |    protected def a(): Int = 1
+        |    @publicInBinary protected def b(): Int = 1
+        |  }
+        |}
+        |package q {
+        |  class B extends p.A {
+        |    trait BInner {
+        |      def test1() = a() // protected accessor for `a`
+        |      def test2() = b() // no protected accessor for `b`
+        |    }
+        |  }
+        |}
+      """.stripMargin
+    checkBCode(code) { dir =>
+      val bClass = loadClassNode(dir.subdirectoryNamed("q").lookupName("B.class", directory = false).input, skipDebugInfo = false)
+      assert(bClass.methods.asScala.exists(_.name == "protected$a"))
+      assert(bClass.methods.asScala.forall(_.name != "protected$b"))
+
+      val bInnerClass = loadClassNode(dir.subdirectoryNamed("q").lookupName("B$BInner.class", directory = false).input, skipDebugInfo = false)
+
+      val test1Method = getMethod(bInnerClass, "test1")
+      val test1Instructions = instructionsFromMethod(test1Method).filter(_.isInstanceOf[Invoke])
+      assertSameCode(test1Instructions, List(
+        Invoke(INVOKEINTERFACE, "q/B$BInner", "q$B$BInner$$$outer", "()Lq/B;", true),
+        Invoke(INVOKEVIRTUAL, "q/B", "protected$a", "()I", false)))
+
+      val test2Method = getMethod(bInnerClass, "test2")
+      val test2Instructions = instructionsFromMethod(test2Method).filter(_.isInstanceOf[Invoke])
+      assertSameCode(test2Instructions, List(
+        Invoke(INVOKEINTERFACE, "q/B$BInner", "q$B$BInner$$$outer", "()Lq/B;", true),
+        Invoke(INVOKEVIRTUAL, "q/B", "b", "()I", false) ))
+    }
+  }
 }

tests/run/noProtectedSuper.scala

@@ -0,0 +1,38 @@
+import scala.annotation.publicInBinary
+
+package p {
+  class A {
+    @publicInBinary protected def foo(): Int = 1
+    @publicInBinary protected def fuzz(): Int = 2
+  }
+}
+package q {
+  class B extends p.A {  // protected accessor for foo
+    trait BInner {
+      def bar() = foo()
+    }
+  }
+  trait Inner extends p.A {
+    def bar() = foo()   // shared super accessor for foo
+                        // new super accessor for fuzz
+    class InnerInner {
+      def bar() = foo()
+      def baz() = fuzz()
+    }
+  }
+}
+object Test extends App {
+  val b = new q.B
+  val bi = new b.BInner {}
+  assert(bi.bar() == 1)
+
+  class C extends p.A with q.Inner {
+    // implements super accessors for foo and fuzz
+  }
+  val c = new C
+  assert(c.bar() == 1)
+
+  val d = new c.InnerInner
+  assert(d.bar() == 1)
+  assert(d.baz() == 2)
+}