Split out testing code from ensureAccessible

Author: odersky

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

@@ -70,6 +70,53 @@ trait TypeAssigner {
     case ex: StaleSymbol => false
   }
 
+  def accessibleType(tpe: Type, superAccess: Boolean)(using Context): Type =
+    tpe match
+      case tpe: NamedType =>
+        val pre = tpe.prefix
+        val name = tpe.name
+        def postProcess(d: Denotation) =
+          if ctx.isJava && tpe.isAnyRef then defn.FromJavaObjectType
+          else TypeOps.makePackageObjPrefixExplicit(tpe withDenot d)
+        val d = tpe.denot.accessibleFrom(pre, superAccess)
+        if d.exists then postProcess(d)
+        else
+          // it could be that we found an inaccessible private member, but there is
+          // an inherited non-private member with the same name and signature.
+          val d2 = pre.nonPrivateMember(name).accessibleFrom(pre, superAccess)
+          if reallyExists(d2) then
+            postProcess(d2)
+          else if (pre.derivesFrom(defn.DynamicClass) && name.isTermName)
+            TryDynamicCallType // TODO: drop
+          else
+            NoType
+      case tpe => tpe
+
+  def ensureAccessible(tpe: Type, superAccess: Boolean, pos: SrcPos)(using Context): Type =
+    val tpe1 = accessibleType(tpe, superAccess)
+    if tpe1.exists then tpe1
+    else tpe match
+      case tpe: NamedType =>
+        val pre = tpe.prefix
+        val name = tpe.name
+        val alts = tpe.denot.alternatives.map(_.symbol).filter(_.exists)
+        var packageAccess = false
+        val whatCanNot = alts match {
+          case Nil =>
+            em"$name cannot"
+          case sym :: Nil =>
+            em"${if (sym.owner == pre.typeSymbol) sym.show else sym.showLocated} cannot"
+          case _ =>
+            em"none of the overloaded alternatives named $name can"
+        }
+        val where = if (ctx.owner.exists) s" from ${ctx.owner.enclosingClass}" else ""
+        val whyNot = new StringBuffer
+        alts.foreach(_.isAccessibleFrom(pre, superAccess, whyNot))
+        if tpe.isError then tpe
+        else errorType(ex"$whatCanNot be accessed as a member of $pre$where.$whyNot", pos)
+      case _ =>
+        tpe
+
   /** If `tpe` is a named type, check that its denotation is accessible in the
    *  current context. Return the type with those alternatives as denotations
    *  which are accessible.
@@ -80,7 +127,7 @@ trait TypeAssigner {
    *      that the package object shows up as the prefix.
    *  (3) in Java compilation units, `Object` is replaced by `defn.FromJavaObjectType`
    */
-  def ensureAccessible(tpe: Type, superAccess: Boolean, pos: SrcPos)(using Context): Type = {
+  def ensureAccessibleOLD(tpe: Type, superAccess: Boolean, pos: SrcPos)(using Context): Type = {
     def test(tpe: Type, firstTry: Boolean): Type = tpe match {
       case tpe: NamedType =>
         val pre = tpe.prefix