Survive inaccessible types when computing implicit scope

Also: Give a better error message later when encountering a missing type that
refers to a private member of a base class. The previous one was misleading since
it referred to a potentially missing class file, which is certainly not the case here.

Fixes scala#21543

Author: odersky

compiler/src/dotty/tools/dotc/core/TypeErrors.scala

@@ -73,6 +73,8 @@ class MissingType(val pre: Type, val name: Name)(using Context) extends TypeErro
       case _ if givenSelf.exists && givenSelf.member(name).exists =>
         i"""$name exists as a member of the self type $givenSelf of $cls
            |but it cannot be called on a receiver whose type does not extend $cls"""
+      case _ if pre.baseClasses.exists(_.findMember(name, pre, Private, EmptyFlags).exists) =>
+        i"$name is a private member in a base class"
       case _ =>
         missingClassFile
 

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -3292,14 +3292,14 @@ object UnusedSymbol {
 
 class NonNamedArgumentInJavaAnnotation(using Context) extends SyntaxMsg(NonNamedArgumentInJavaAnnotationID):
 
-  override protected def msg(using Context): String = 
+  override protected def msg(using Context): String =
     "Named arguments are required for Java defined annotations"
     + Message.rewriteNotice("This", version = SourceVersion.`3.6-migration`)
 
-  override protected def explain(using Context): String = 
+  override protected def explain(using Context): String =
     i"""Starting from Scala 3.6.0, named arguments are required for Java defined annotations.
-        |Java defined annotations don't have an exact constructor representation 
-        |and we previously relied on the order of the fields to create one. 
+        |Java defined annotations don't have an exact constructor representation
+        |and we previously relied on the order of the fields to create one.
         |One possible issue with this representation is the reordering of the fields.
         |Lets take the following example:
         |

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -821,6 +821,10 @@ trait ImplicitRunInfo:
           override def stopAt = StopAt.Static
           private val seen = util.HashSet[Type]()
 
+          override def derivedTypeBounds(tp: TypeBounds, lo: Type, hi: Type): Type =
+            if lo.exists && hi.exists then super.derivedTypeBounds(tp, lo, hi)
+            else NoType // Survive inaccessible types, for instance in i21543.scala.
+
           def applyToUnderlying(t: TypeProxy) =
             if seen.contains(t) then
               WildcardType

tests/neg/i21543.scala

@@ -0,0 +1,13 @@
+object CompilerCrash {
+  trait Scope {
+    private type Event = String
+
+    case class Cmd(events: List[Event])
+  }
+
+  new Scope {
+    val commands = List(
+      Cmd(List("1", "2"))
+    )
+  }
+}