Erasure#typedSelect: Handle inaccessible qualifier

Previously, the code would have gone into an infinite loop, instead we
now emit an error like in Scala 2.

Author: smarter

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

@@ -20,6 +20,7 @@ import core.Annotations.BodyAnnotation
 import typer.{NoChecking, LiftErased}
 import typer.Inliner
 import typer.ProtoTypes._
+import typer.ErrorReporting.errorTree
 import core.TypeErasure._
 import core.Decorators._
 import dotty.tools.dotc.ast.{tpd, untpd}
@@ -700,8 +701,17 @@ object Erasure {
           else
             val castTarget = // Avoid inaccessible cast targets, see i8661
               if sym.owner.isAccessibleFrom(qual1.tpe)(using preErasureCtx)
-              then sym.owner.typeRef
-              else erasure(tree.qualifier.typeOpt.widen)
+              then
+                sym.owner.typeRef
+              else
+                // If the owner is inaccessible, try going through the qualifier,
+                // but be careful to not go in an infinite loop in case that doesn't
+                // work either.
+                val tp = erasure(tree.qualifier.typeOpt.widen)
+                if tp =:= qual1.tpe.widen then
+                  return errorTree(qual1,
+                    ex"Unable to emit reference to ${sym.showLocated}, ${sym.owner} is not accessible in ${ctx.owner.enclosingClass}")
+                tp
             recur(cast(qual1, castTarget))
         }
       }

tests/neg/java-trait-access/A.java

@@ -0,0 +1,5 @@
+package pkg;
+
+class A {
+  public void foo() {}
+}

tests/neg/java-trait-access/B.scala

@@ -0,0 +1,13 @@
+package pkg {
+  trait B extends A
+  class C extends B
+}
+
+object Test {
+  def test1: Unit = {
+    val c = new pkg.C
+    c.foo() // OK
+    val b: pkg.B = c
+    b.foo() // error: Unable to emit reference to method foo in class A, class A is not accessible in object Test
+  }
+}