checkNoPrivateLeaks: handle references to companion members

Previously Outer2#Inner#foo failed to compile with:
```
    non-private method foo refers to private value x in its type signature
```

This should compile because the boundary of `foo` is `class Outer2`
and the boundary of `x` is `object Outer2`. This commit fixes this by
also considering the linked boundary in `checkNoPrivateLeaks`.

Author: smarter

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

@@ -353,17 +353,31 @@ object Checking {
     class NotPrivate extends TypeMap {
       type Errors = List[(String, Position)]
       var errors: Errors = Nil
+
       def accessBoundary(sym: Symbol): Symbol =
         if (sym.is(Private)) sym.owner
         else if (sym.privateWithin.exists) sym.privateWithin
         else if (sym.is(Package)) sym
         else accessBoundary(sym.owner)
+
+      val symBoundary = accessBoundary(sym)
+
+      /** Is `other` leaked outside its access boundary ?
+       *  @pre  The signature of `sym` refers to `other`
+       */
+      def isLeaked(other: Symbol) =
+        other.is(Private) && {
+          val otherBoundary = other.owner
+          val otherLinkedBoundary = otherBoundary.linkedClass
+          !(symBoundary.isContainedIn(otherBoundary) ||
+            otherLinkedBoundary.exists && symBoundary.isContainedIn(otherLinkedBoundary))
+        }
+
       def apply(tp: Type): Type = tp match {
         case tp: NamedType =>
           val prevErrors = errors
           var tp1 =
-            if (tp.symbol.is(Private) &&
-                !accessBoundary(sym).isContainedIn(tp.symbol.owner)) {
+            if (isLeaked(tp.symbol)) {
               errors = (em"non-private $sym refers to private ${tp.symbol}\n in its type signature ${sym.info}",
                         sym.pos) :: errors
               tp

tests/neg/leaks.scala

@@ -0,0 +1,7 @@
+class Outer {
+  private val x: Int = 1
+
+  class Inner {
+    def foo: x.type = x // error: non-private method foo refers to private value x in its type signature
+  }
+}

tests/pos/leaks.scala

@@ -0,0 +1,17 @@
+class Outer1 {
+  private val x: Int = 1
+
+  private class Inner {
+    def foo: x.type = x // OK
+  }
+}
+
+object Outer2 {
+  private val x: Int = 1
+}
+
+class Outer2 {
+  private class Inner {
+    def foo: Outer2.x.type = Outer2.x // OK
+  }
+}