Fix #10311: Inaccessible members do not qualify for SelectionProtos

Author: odersky

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

@@ -180,10 +180,12 @@ object ProtoTypes {
       {
         val mbr = if (privateOK) tp1.member(name) else tp1.nonPrivateMember(name)
         def qualifies(m: SingleDenotation) =
-          memberProto.isRef(defn.UnitClass) ||
-          tp1.isValueType && compat.normalizedCompatible(NamedType(tp1, name, m), memberProto, keepConstraint)
-            // Note: can't use `m.info` here because if `m` is a method, `m.info`
-            //       loses knowledge about `m`'s default arguments.
+          val isAccessible = !m.symbol.exists || m.symbol.isAccessibleFrom(tp1, superAccess = true)
+          isAccessible
+          && (memberProto.isRef(defn.UnitClass)
+             || tp1.isValueType && compat.normalizedCompatible(NamedType(tp1, name, m), memberProto, keepConstraint))
+              // Note: can't use `m.info` here because if `m` is a method, `m.info`
+              //       loses knowledge about `m`'s default arguments.
         mbr match { // hasAltWith inlined for performance
           case mbr: SingleDenotation => mbr.exists && qualifies(mbr)
           case _ => mbr hasAltWith qualifies

tests/neg/overloading-specifity.scala

@@ -23,5 +23,6 @@ object Test extends App {
     def foo[T]: Show[T] = new Show[T](2)
   }
 
-  assert(a.foo[Int].i == 2) // error: no implicit argument of type Test.Context was found for parameter ctx
+  val b = a.foo[Int] // error: no implicit argument of type context found
+  assert(b.i == 1)   // error
 }

tests/pos/i10311.scala

@@ -0,0 +1,15 @@
+object Module {
+  class MyInt(private val x: Int, private val y: Int)
+  object MyInt {
+    implicit class Ops(self: MyInt) extends AnyVal {
+      def x: Int = self.x
+    }
+    extension (self: MyInt) def y: Int = self.y
+  }
+}
+object test:
+  import Module._
+
+  val a = new MyInt(42, 43)
+  val b = a.x
+  val c = a.y

tests/run/overloading-specifity-2.scala

@@ -0,0 +1,27 @@
+// Shows that overloading resolution does not test implicits to decide
+// applicability. A best alternative is picked first, and then implicits
+// are searched for this one.
+case class Show[T](val i: Int)
+class Show1[T](i: Int) extends Show[T](i)
+
+class Generic
+object Generic {
+  implicit val gen: Generic = new Generic
+  implicit def showGen[T](implicit gen: Generic): Show[T] = new Show[T](2)
+}
+
+object Test extends App {
+  trait Context
+  //given ctx as Context
+
+  object a {
+    def foo[T](implicit gen: Generic): Show[T] = new Show[T](1)
+    def foo[T](implicit gen: Generic, ctx: Context): Show1[T] = new Show1[T](2)
+  }
+  object b {
+    def foo[T](implicit gen: Generic): Show[T] = new Show[T](1)
+    def foo[T]: Show[T] = new Show[T](2)
+  }
+
+  assert(a.foo[Int].i == 1) // error: no implicit argument of type Test.Context was found for parameter ctx
+}