Infer private[this]

Infer private[this] if all accesses are via this, even if it is not explicitly given.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -155,7 +155,7 @@ object desugar {
     val vdef @ ValDef(name, tpt, rhs) = transformQuotedPatternName(vdef0)
     val mods = vdef.mods
     val setterNeeded =
-      mods.is(Mutable) && ctx.owner.isClass && (!mods.isAllOf(PrivateLocal) || ctx.owner.is(Trait))
+      mods.is(Mutable) && ctx.owner.isClass && (!mods.is(Private) || ctx.owner.is(Trait))
     if (setterNeeded) {
       // TODO: copy of vdef as getter needed?
       // val getter = ValDef(mods, name, tpt, rhs) withPos vdef.pos?

compiler/src/dotty/tools/dotc/transform/Getters.scala

@@ -10,6 +10,10 @@ import Symbols._
 import MegaPhase._
 import Flags._
 import ValueClasses._
+import SymUtils._
+import NameOps._
+import collection.mutable
+
 
 /** Performs the following rewritings for fields of a class:
  *
@@ -46,7 +50,7 @@ import ValueClasses._
  *  Also, drop the Local flag from all private[this] and protected[this] members.
  *  This allows subsequent code motions in Flatten.
  */
-class Getters extends MiniPhase with SymTransformer {
+class Getters extends MiniPhase with SymTransformer { thisPhase =>
   import ast.tpd._
 
   override def phaseName: String = Getters.name
@@ -80,11 +84,31 @@ class Getters extends MiniPhase with SymTransformer {
   }
   private val NoGetterNeededFlags = Method | Param | JavaDefined | JavaStatic
 
+  val newSetters = mutable.HashSet[Symbol]()
+
+  def ensureSetter(sym: TermSymbol)(given Context) =
+    if !sym.setter.exists then
+      newSetters += sym.copy(
+        name = sym.name.setterName,
+        info = MethodType(sym.info.widenExpr :: Nil, defn.UnitType)
+      ).enteredAfter(thisPhase)
+
   override def transformValDef(tree: ValDef)(implicit ctx: Context): Tree =
-    if (tree.symbol.is(Method)) DefDef(tree.symbol.asTerm, tree.rhs).withSpan(tree.span) else tree
+    val sym = tree.symbol
+    if !sym.is(Method) then return tree
+    val getterDef = DefDef(sym.asTerm, tree.rhs).withSpan(tree.span)
+    if !sym.is(Mutable) then return getterDef
+    ensureSetter(sym.asTerm)
+    if !newSetters.contains(sym.setter) then return getterDef
+    val setterDef = DefDef(sym.setter.asTerm, unitLiteral)
+    Thicket(getterDef, setterDef)
 
   override def transformAssign(tree: Assign)(implicit ctx: Context): Tree =
-    if (tree.lhs.symbol.is(Method)) tree.lhs.becomes(tree.rhs).withSpan(tree.span) else tree
+    val lsym = tree.lhs.symbol.asTerm
+    if (lsym.is(Method))
+      ensureSetter(lsym)
+      tree.lhs.becomes(tree.rhs).withSpan(tree.span)
+    else tree
 }
 
 object Getters {