Erasure#typedSelect: Proper accessibility checking

We only need to avoid things which are inaccessible from the JVM point
of view, so `c.a` should typecheck because `protected[foo] trait A` will
be emitted as a public interface.

Author: smarter

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

@@ -685,6 +685,21 @@ object Erasure {
           qual
       }
 
+      /** Can we safely use `cls` as a qualifier without getting a runtime error on
+       *  the JVM due to its accessibility checks?
+       */
+      def isJvmAccessible(cls: Symbol): Boolean =
+        // Scala classes are always emitted as public, unless the
+        // `private` modifier is used, but a non-private class can never
+        // extend a private class, so such a class will never be a cast target.
+        !cls.is(Flags.JavaDefined) || {
+          // We can't rely on `isContainedWith` here because packages are
+          // not nested from the JVM point of view.
+          val boundary = cls.accessBoundary(cls.owner)(using preErasureCtx)
+          (boundary eq defn.RootClass) ||
+          (ctx.owner.enclosingPackageClass eq boundary)
+        }
+
       def recur(qual: Tree): Tree = {
         val qualIsPrimitive = qual.tpe.widen.isPrimitiveValueType
         val symIsPrimitive = sym.owner.isPrimitiveValueClass
@@ -704,7 +719,7 @@ object Erasure {
             select(qual1, sym)
           else
             val castTarget = // Avoid inaccessible cast targets, see i8661
-              if sym.owner.isAccessibleFrom(qual1.tpe)(using preErasureCtx)
+              if isJvmAccessible(sym.owner)
               then
                 sym.owner.typeRef
               else

tests/pos/trait-access.scala

@@ -0,0 +1,13 @@
+package foo {
+  protected[foo] trait A {
+    def a: Unit = {}
+  }
+  class B extends A
+}
+trait C extends foo.B
+object Test {
+  def test: Unit = {
+    val c = new C {}
+    c.a
+  }
+}