Fix #9051: Fix accessibility test for implicit candidates

If it comes from a type's implicit scope, accessibility from a context should not
matter to determine the initially eligible candidates. Accessibility will be tested
later when an implicit is tried.

Author: odersky

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

@@ -99,6 +99,8 @@ object Implicits {
       if (wtp.derivesFrom(SingletonClass)) defn.AnyType else wtp
     }
 
+    protected def isAccessible(ref: TermRef)(using Context): Boolean
+
     /** Return those references in `refs` that are compatible with type `pt`. */
     protected def filterMatching(pt: Type)(using Context): List[Candidate] = {
       record("filterMatching")
@@ -197,7 +199,8 @@ object Implicits {
               case _ => tp
 
         var ckind =
-          if (!ref.symbol.isAccessibleFrom(ref.prefix)) Candidate.None
+          if !isAccessible(ref) then
+            Candidate.None
           else pt match {
             case pt: ViewProto =>
               viewCandidateKind(ref.widen, pt.argType, pt.resType)
@@ -244,7 +247,9 @@ object Implicits {
    */
   class OfTypeImplicits(tp: Type, val companionRefs: TermRefSet)(initctx: Context) extends ImplicitRefs(initctx) {
     assert(initctx.typer != null)
-    implicits.println(i"implicits of type $tp = ${companionRefs.toList}%, %")
+
+    implicits.println(i"implicit scope of type $tp = ${companionRefs.toList}%, %")
+
     @threadUnsafe lazy val refs: List[ImplicitRef] = {
       val buf = new mutable.ListBuffer[TermRef]
       for (companion <- companionRefs) buf ++= companion.implicitMembers
@@ -258,6 +263,9 @@ object Implicits {
         filterMatching(tp)
       }
 
+    override def isAccessible(ref: TermRef)(using Context): Boolean =
+      ref.symbol.exists && !ref.symbol.is(Private)
+
     override def toString: String =
       i"OfTypeImplicits($tp), companions = ${companionRefs.toList}%, %; refs = $refs%, %."
   }
@@ -325,6 +333,9 @@ object Implicits {
       }
     }
 
+    override def isAccessible(ref: TermRef)(using Context): Boolean =
+      ref.symbol.isAccessibleFrom(ref.prefix)
+
     override def toString: String = {
       val own = i"(implicits: $refs%, %)"
       if (isOuterMost) own else own + "\n " + outerImplicits
@@ -967,7 +978,9 @@ trait Implicits { self: Typer =>
             case _ =>
               tryConversion
         }
-      if (ctx.reporter.hasErrors) {
+      if ctx.reporter.hasErrors
+         || !cand.ref.symbol.isAccessibleFrom(cand.ref.prefix)
+      then
         ctx.reporter.removeBufferedMessages
         adapted.tpe match {
           case _: SearchFailureType => SearchFailure(adapted)
@@ -979,13 +992,11 @@ trait Implicits { self: Typer =>
             else
               SearchFailure(adapted.withType(new MismatchedImplicit(ref, pt, argument)))
         }
-      }
-      else {
+      else
         val returned =
           if (cand.isExtension) Applications.ExtMethodApply(adapted)
           else adapted
         SearchSuccess(returned, ref, cand.level)(ctx.typerState, ctx.gadt)
-      }
     }
 
   /** An implicit search; parameters as in `inferImplicit` */
@@ -1010,8 +1021,6 @@ trait Implicits { self: Typer =>
 
     val isNot: Boolean = wildProto.classSymbol == defn.NotClass
 
-      //println(i"search implicits $pt / ${eligible.map(_.ref)}")
-
     /** Try to type-check implicit reference, after checking that this is not
       * a diverging search
       */

tests/neg/i9051.scala

@@ -0,0 +1,11 @@
+package zio:
+
+  class ZRef
+  object ZRef:
+
+    private[zio] implicit class ZRefSyntax(private val self: ZRef):
+      def unsafeUpdate: Boolean = true
+
+object Main:
+  val ref = new zio.ZRef
+  println(ref.unsafeUpdate)  // error

tests/pos/i9051.scala

@@ -0,0 +1,15 @@
+package zio
+
+class ZRef
+
+object ZRef {
+
+  private[zio] implicit class ZRefSyntax(private val self: ZRef) extends AnyVal {
+    def unsafeUpdate: Boolean = true
+  }
+}
+
+object Main extends App {
+  val ref = new ZRef
+  println(ref.unsafeUpdate)
+}