New miniphase: ExpandPrivate

A late miniphase which resets private flag of all
members that are not accessed from within same class.
Replaces logic in RefChecks. Doing this late has two
advantages

 - we can use name expansion, because references are
   symbolic, so the names of symbols and references
   to them do not need to correspond anymore.
 - we can automatically correct for symbols moved in earlier
   phases (e.g. lifted out by LambdaLift).

Author: odersky

src/dotty/tools/dotc/Compiler.scala

@@ -65,7 +65,12 @@ class Compiler {
       List(new LambdaLift,   // in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
            new Flatten,
            new RestoreScopes),
-      List(/*new PrivateToStatic,*/ new CollectEntryPoints, new LabelDefs, new ElimWildcardIdents, new TraitConstructors),
+      List(/*new PrivateToStatic,*/
+           new ExpandPrivate,
+           new CollectEntryPoints,
+           new LabelDefs,
+           new ElimWildcardIdents,
+           new TraitConstructors),
       List(new GenBCode)
     )
 

src/dotty/tools/dotc/transform/ExpandPrivate.scala

@@ -0,0 +1,49 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers.IdentityDenotTransformer
+import Contexts.Context
+import Symbols._
+import Scopes._
+import Flags._
+import StdNames._
+import SymDenotations._
+import Types._
+import collection.mutable
+import TreeTransforms._
+import Decorators._
+import ast.Trees._
+import TreeTransforms._
+
+/** Makes private methods static, provided they not deferred, accessors, or static,
+ *  by rewriting a method `m` in class `C` as follows:
+ *
+ *     private def m(ps) = e
+ *
+ *     --> private static def($this: C, ps) = [this -> $this] e
+ */
+class ExpandPrivate extends MiniPhaseTransform with IdentityDenotTransformer { thisTransform =>
+  import ast.tpd._
+
+  override def phaseName: String = "expandPrivate"
+
+  /** Make private terms accessed from different classes non-private.
+   *  Note: this happens also for accesses between class and linked module class.
+   *  If we change the scheme at one point to make static module class computations
+   *  static members of the companion class, we should tighten the condition below.
+   */
+  private def ensurePrivateAccessible(d: SymDenotation)(implicit ctx: Context) =
+    if (d.is(PrivateTerm) && d.owner != ctx.owner.enclosingClass)
+      d.ensureNotPrivate.installAfter(thisTransform)
+
+  override def transformIdent(tree: Ident)(implicit ctx: Context, info: TransformerInfo) = {
+    ensurePrivateAccessible(tree.symbol)
+    tree
+  }
+
+  override def transformSelect(tree: Select)(implicit ctx: Context, info: TransformerInfo) = {
+    ensurePrivateAccessible(tree.symbol)
+    tree
+  }
+}

src/dotty/tools/dotc/typer/RefChecks.scala

@@ -726,40 +726,14 @@ import RefChecks._
  *  todo: But RefChecks is not done yet. It's still a somewhat dirty port from the Scala 2 version.
  *  todo: move untrivial logic to their own mini-phases
  */
-class RefChecks extends MiniPhase with SymTransformer { thisTransformer =>
+class RefChecks extends MiniPhase { thisTransformer =>
 
   import tpd._
 
   override def phaseName: String = "refchecks"
 
   val treeTransform = new Transform(NoLevelInfo)
 
-  /** Ensure the following members are not private:
-   *   - term members of traits
-   *   - the primary constructor of a value class
-   *   - the parameter accessor of a value class
-   */
-  override def transformSym(d: SymDenotation)(implicit ctx: Context) = {
-    def mustBePublicInValueClass = d.isPrimaryConstructor || d.is(ParamAccessor)
-    def mustBePublic = {
-      val cls = d.owner
-      (isDerivedValueClass(cls) && mustBePublicInValueClass
-    }
-    if ((d is PrivateTerm) && mustBePublic) notPrivate(d) else d
-  }
-
-  /** Make private terms accessed from different classes non-private.
-   *  Note: this happens also for accesses between class and linked module class.
-   *  If we change the scheme at one point to make static module class computations
-   *  static members of the companion class, we should tighten the condition below.
-   */
-  private def ensurePrivateAccessible(d: SymDenotation)(implicit ctx: Context) =
-    if (d.is(PrivateTerm) && d.owner != ctx.owner.enclosingClass)
-      notPrivate(d).installAfter(thisTransformer)
-
-  private def notPrivate(d: SymDenotation)(implicit ctx: Context) =
-    d.copySymDenotation(initFlags = d.flags | NotJavaPrivate)
-
   class Transform(currentLevel: RefChecks.OptLevelInfo = RefChecks.NoLevelInfo) extends TreeTransform {
     def phase = thisTransformer
 
@@ -810,14 +784,12 @@ class RefChecks extends MiniPhase with SymTransformer { thisTransformer =>
 
     override def transformIdent(tree: Ident)(implicit ctx: Context, info: TransformerInfo) = {
       checkUndesiredProperties(tree.symbol, tree.pos)
-      ensurePrivateAccessible(tree.symbol)
       currentLevel.enterReference(tree.symbol, tree.pos)
       tree
     }
 
     override def transformSelect(tree: Select)(implicit ctx: Context, info: TransformerInfo) = {
       checkUndesiredProperties(tree.symbol, tree.pos)
-      ensurePrivateAccessible(tree.symbol)
       tree
     }
 

tests/pos/privates.scala

@@ -6,4 +6,8 @@ trait Test {
 
   private def bar() = foo()
 
+  class Inner {
+    foo()
+  }
+
 }