SI-7475 Private members are not inheritable

Exclude them from superclasses in `findMember` and in
`OverridingPairs`.

The odd logic in `findMember` that considered whether the
selector class was owned by the owner of the candidate private
symbol dates back to 2007 (bff4268), but does not appear to
have any relationship to the spec.

Refinement types are still able to inherit private members from
all direct parents, as was needed in pos/t2399.scala. More tests
are included for this scenario.

In short, the logic now:

 - includes direct parents of refinements,
 - otherwise, excludes privates after the first class in the
   base class sequence

Author: retronym

src/compiler/scala/tools/nsc/transform/OverridingPairs.scala

@@ -34,8 +34,12 @@ abstract class OverridingPairs {
      *  and hidden symbols, including bridges. But it may be refined in subclasses.
      *
      */
-    protected def exclude(sym: Symbol): Boolean =
-      sym.isConstructor || sym.isPrivateLocal || sym.isArtifact
+    protected def exclude(sym: Symbol): Boolean = (
+         sym.isConstructor
+      || sym.isPrivateLocal
+      || (sym.isPrivate && sym.owner != base)
+      || sym.isArtifact
+    )
 
     /** The parents of base (may also be refined).
      */

src/reflect/scala/reflect/internal/Types.scala

@@ -1069,22 +1069,16 @@ trait Types
         //Console.println("find member " + name.decode + " in " + this + ":" + this.baseClasses)//DEBUG
         var membertpe: Type = null
         var required = requiredFlags
-        var excluded = excludedFlags | DEFERRED
+        var excluded: Long = excludedFlags | DEFERRED
+        var seenFirstNonRefinementClass: Boolean = false
         var continue = true
         var self: Type = null
+        var refinementParents: List[Symbol] = Nil
 
         while (continue) {
           continue = false
           val bcs0 = baseClasses
           var bcs = bcs0
-          // omit PRIVATE LOCALS unless selector class is contained in class owning the def.
-          def admitPrivateLocal(owner: Symbol): Boolean = {
-            val selectorClass = this match {
-              case tt: ThisType => tt.sym // SI-7507 the first base class is not necessarily the selector class.
-              case _            => bcs0.head
-            }
-            selectorClass.hasTransOwner(owner)
-          }
           while (!bcs.isEmpty) {
             val decls = bcs.head.info.decls
             var entry = decls.lookupEntry(name)
@@ -1095,9 +1089,12 @@ trait Types
                 val excl = flags & excluded
                 val isMember = (
                      excl == 0L
-                  && (    (bcs eq bcs0)
-                       || (flags & PrivateLocal) != PrivateLocal
-                       || admitPrivateLocal(bcs.head)
+                  && (
+                          (flags & PRIVATE) != PRIVATE              // non-privates are always members
+                       || (
+                               !seenFirstNonRefinementClass         // classes don't inherit privates
+                            || refinementParents.contains(bcs.head) // refinements inherit privates of direct parents
+                          )
                      )
                 )
                 if (isMember) {
@@ -1152,7 +1149,13 @@ trait Types
               }
               entry = decls lookupNextEntry entry
             } // while (entry ne null)
-            // excluded = excluded | LOCAL
+
+            val sym = bcs.head
+            if (sym.isRefinementClass)
+              refinementParents :::= bcs.head.parentSymbols // keep track of direct parents of refinements
+            else if (sym.isClass)
+              seenFirstNonRefinementClass = true
+
             bcs = if (name == nme.CONSTRUCTOR) Nil else bcs.tail
           } // while (!bcs.isEmpty)
           required |= DEFERRED

test/files/neg/t7475c.check

@@ -0,0 +1,7 @@
+t7475c.scala:6: error: value a is not a member of A.this.B
+    println(this.a)     // wait, what?
+                 ^
+t7475c.scala:7: error: value b is not a member of A.this.B
+    println(this.b)     // wait, what?
+                 ^
+two errors found

test/files/neg/t7475c.scala

@@ -0,0 +1,9 @@
+class A {
+  private val a: Int = 0
+  private[this] val b: Int = 0
+  class B extends A {
+    def foo(a: A) = a.a // okay
+    println(this.a)     // wait, what?
+    println(this.b)     // wait, what?
+  }
+}

test/files/neg/t7475d.check

@@ -0,0 +1,7 @@
+t7475d.scala:4: error: value priv is not a member of T.this.TT
+  (??? : TT).priv
+             ^
+t7475d.scala:10: error: value priv is not a member of U.this.UU
+  (??? : UU).priv
+             ^
+two errors found

test/files/neg/t7475e.check

@@ -0,0 +1,4 @@
+t7475e.scala:8: error: value priv is not a member of Base.this.TT
+  (??? : TT).priv
+             ^
+one error found

test/files/neg/t7475e.scala

@@ -0,0 +1,12 @@
+trait U {
+}
+
+trait Base {
+  private val priv = 0
+
+  type TT = U with T // should exclude `priv`
+  (??? : TT).priv
+}
+
+trait T extends Base {
+}

test/files/pos/t7475a.scala

@@ -0,0 +1,11 @@
+trait AbstractPublic {
+  def queue: Any
+}
+trait ConcretePrivate {
+  private val queue: Any = ()
+}
+
+abstract class Mix
+  extends ConcretePrivate with AbstractPublic {
+  final def queue: Any = ()
+}

test/files/pos/t7475b.scala

@@ -0,0 +1,8 @@
+trait U {
+}
+
+trait T {
+  type TT = Any with T with U
+  private val priv = 0
+  (??? : TT).priv
+}

test/files/pos/t7475d.scala

@@ -0,0 +1,11 @@
+trait T {
+  type TT = T with Any
+  private val priv = 0
+  (??? : TT).priv
+}
+
+trait U {
+  type UU = Any with U
+  private val priv = 0
+  (??? : UU).priv
+}

test/files/pos/t7475e.scala

@@ -0,0 +1,13 @@
+trait U {
+  private val priv = 0
+  type TT = U with T // should allow `priv`
+  (??? : TT).priv
+}
+
+trait Base {
+
+}
+
+trait T extends Base {
+
+}

test/files/run/t7475b.check

@@ -0,0 +1,2 @@
+2
+2

test/files/run/t7475b.scala

@@ -0,0 +1,11 @@
+trait A { private val x = 1 }
+trait B { val x = 2 }
+trait C1 extends B with A { println(x) }
+trait C2 extends A with B { println(x) }
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    new C1 { }
+    new C2 { }
+  }
+}