Make private term members Local if accessed only from this

Make private term members Local if they are accessed only from
their owner's this-type.

Author: odersky

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -795,6 +795,9 @@ object SymDenotations {
      *  @param superAccess  Access is via super
      *  Everything is accessible if `pre` is `NoPrefix`.
      *  A symbol with type `NoType` is not accessible for any other prefix.
+     *  
+     *  As a side effect, drop Local flags of members that are not accessed via the ThisType
+     *  of their owner.
      */
     final def isAccessibleFrom(pre: Type, superAccess: Boolean = false, whyNot: StringBuffer = null)(implicit ctx: Context): Boolean = {
 
@@ -855,6 +858,11 @@ object SymDenotations {
         || (accessWithin(boundary) || accessWithinLinked(boundary)) &&
              (  !this.is(Local)
              || isCorrectThisType(pre)
+             || canBeLocal(name, flags)
+                && {
+                  resetFlag(Local)
+                  true
+                }
              )
         || this.is(Protected) &&
              (  superAccess
@@ -2184,6 +2192,20 @@ object SymDenotations {
     validFor = Period.allInRun(NoRunId)
   }
 
+  /** Can a pruvate symbol with given name and flags be inferred to be local,
+   *  if all references to such symbols are via `this`?
+   *  This holds for all term symbols, except
+   *   - constructors, since they can never be referred to as members of their
+   *     own, fully elaborated `this`.
+   *   - parameters and parameter accessors, since their Local status is already
+   *     determined by whether they have a `val` or `var` or not.
+   */
+  def canBeLocal(name: Name, flags: FlagSet)(given Context) =
+    name.isTermName
+    && !name.isConstructorName
+    && !flags.is(Param)
+    && !flags.is(ParamAccessor)
+
   // ---- Completion --------------------------------------------------------
 
   /** Instances of LazyType are carried by uncompleted symbols.

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

@@ -276,6 +276,9 @@ class Namer { typer: Typer =>
     /** Check that flags are OK for symbol. This is done early to avoid
      *  catastrophic failure when we create a TermSymbol with TypeFlags, or vice versa.
      *  A more complete check is done in checkWellFormed.
+     *  Also, speculatively add a Local flag to private members that can be Local if
+     *  referred to exclusively from their owner's this-type. The Local flag is retracted in
+     *  `isAccessibleFrom` if the access not from such a this-type.
      */
     def checkFlags(flags: FlagSet) =
       if (flags.isEmpty) flags
@@ -284,9 +287,12 @@ class Namer { typer: Typer =>
           case tree: TypeDef => (flags.isTypeFlags, flags.toTypeFlags, "type")
           case _ => (flags.isTermFlags, flags.toTermFlags, "value")
         }
-        if (!ok)
+        def canBeLocal = tree match
+          case tree: ValOrDefDef => SymDenotations.canBeLocal(tree.name, flags)
+          case _ => false
+        if !ok then
           ctx.error(i"modifier(s) `${flags.flagsString}` incompatible with $kind definition", tree.sourcePos)
-        adapted
+        if adapted.is(Private) && canBeLocal then adapted | Local else adapted
       }
 
     /** Add moduleClass/sourceModule to completer if it is for a module val or class */

tests/run/i1692.scala

@@ -16,6 +16,9 @@ class LazyNullable(a: => Int) {
   private [this] val e = "E"
   lazy val l4 = try e finally () // null out e
 
+  private val eInf = "E" // still nullable because private[this] is inferred
+  lazy val l4Inf = eInf
+
   private[this] val i = "I"
   // null out i even though the try ends up lifted, because the LazyVals phase runs before the LiftTry phase
   lazy val l5 = try i catch { case e: Exception => () }
@@ -39,9 +42,6 @@ class LazyNotNullable {
   private[this] lazy val d = "D" // not nullable because lazy
   lazy val l3 = d
 
-  private val e = "E" // not nullable because not private[this]
-  lazy val l4 = e
-
   private[this] val f = "F" // not nullable because used in mutiple lazy vals
   lazy val l5 = f
   lazy val l6 = f
@@ -98,6 +98,9 @@ object Test {
     assert(lz.l4 == "E")
     assertNull("e")
 
+    assert(lz.l4Inf == "E")
+    assertNull("eInf")
+
     assert(lz.l5 == "I")
     assertNull("i")
 
@@ -124,9 +127,6 @@ object Test {
 
     assert(lz.l3 == "D")
 
-    assert(lz.l4 == "E")
-    assertNotNull("e")
-
     assert(lz.l5 == "F")
     assert(lz.l6 == "F")
     assertNotNull("f")

tests/run/i1692b.scala

@@ -18,6 +18,9 @@ class LazyNullable(a: => Int) {
   private [this] val e = "E"
   @threadUnsafe lazy val l4 = try e finally () // null out e
 
+  private val eInf = "E"
+  @threadUnsafe lazy val l4Inf = try eInf finally () // null out e, since private[this] is inferred
+
   private[this] val i = "I"
   // null out i even though the try ends up lifted, because the LazyVals phase runs before the LiftTry phase
   @threadUnsafe lazy val l5 = try i catch { case e: Exception => () }
@@ -41,9 +44,6 @@ class LazyNotNullable {
   @threadUnsafe private[this]  lazy val d = "D" // not nullable because lazy
   @threadUnsafe lazy val l3 = d
 
-  private val e = "E" // not nullable because not private[this]
-  @threadUnsafe lazy val l4 = e
-
   private[this] val f = "F" // not nullable because used in mutiple @threadUnsafe lazy vals
   @threadUnsafe lazy val l5 = f
   @threadUnsafe lazy val l6 = f
@@ -100,6 +100,9 @@ object Test {
     assert(lz.l4 == "E")
     assertNull("e")
 
+    assert(lz.l4Inf == "E")
+    assertNull("eInf")
+
     assert(lz.l5 == "I")
     assertNull("i")
 
@@ -126,9 +129,6 @@ object Test {
 
     assert(lz.l3 == "D")
 
-    assert(lz.l4 == "E")
-    assertNotNull("e")
-
     assert(lz.l5 == "F")
     assert(lz.l6 == "F")
     assertNotNull("f")