Fix #4811: Exclude fields when widening private[this]/protected[this]

This fix the crash because we don't need to generate a getter or setter
for private[this] field anymore.

The original documentation for ElimLocals says:

This phase drops the Local flag from all private[this] and protected[this] members.
This allows subsequent code motions where code is moved from a class to its
companion object. It invalidates variance checking, which is consequently disabled
when retyping.

We maintain the Local flag for field since then cannot move to the companion object
and it is used later in Getter.

Author: allanrenucci

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -61,9 +61,9 @@ class Compiler {
     List(new FirstTransform,         // Some transformations to put trees into a canonical form
          new CheckReentrant,         // Internal use only: Check that compiled program has no data races involving global vars
          new ElimPackagePrefixes) :: // Eliminate references to package prefixes in Select nodes
-    List(new CheckStatic,            // Check restrictions that apply to @static members
+    List(new ElimLocals,             // Widens private[this] and protected[this] modifiers to just private/protected
+         new CheckStatic,            // Check restrictions that apply to @static members
          new ElimRepeated,           // Rewrite vararg parameters and arguments
-         new NormalizeFlags,         // Rewrite some definition flags
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
          new ProtectedAccessors,     // Add accessors for protected members
          new ExtensionMethods,       // Expand methods of value classes with extension methods

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

@@ -0,0 +1,30 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers.SymTransformer
+import Phases.Phase
+import Contexts.Context
+import SymDenotations.SymDenotation
+import MegaPhase.MiniPhase
+import Flags._, Symbols._
+import SymUtils._
+
+/** This phase drops the Local flag from all private[this] and protected[this] members.
+ *
+ *  This allows subsequent code motions where code is moved from a class to its
+ *  companion object.
+ *  We maintain the Local flag for field since then cannot move to the companion
+ *  object and it is used in later Getter.
+ */
+class ElimLocals extends MiniPhase with SymTransformer {
+  override def phaseName = ElimLocals.name
+
+  def transformSym(ref: SymDenotation)(implicit ctx: Context) =
+    if (ref.is(Local) && !ref.isField) ref.copySymDenotation(initFlags = ref.flags &~ Local)
+    else ref
+}
+
+object ElimLocals {
+  def name = "elimlocals"
+}

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

@@ -47,7 +47,9 @@ class ExtensionMethods extends MiniPhase with DenotTransformer with FullParamete
 
   override def runsAfter = Set(
     ElimRepeated.name,
-    ProtectedAccessors.name  // protected accessors cannot handle code that is moved from class to companion object
+    ProtectedAccessors.name,  // protected accessors cannot handle code that is moved from class to companion object
+    ElimLocals.name           // private[this] accessors need to be widened before
+                              // a methods is moved to its companion object
   )
 
   override def runsAfterGroupsOf = Set(FirstTransform.name) // need companion objects to exist

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

@@ -17,6 +17,9 @@ class Flatten extends MiniPhase with SymTransformer {
 
   override def phaseName = "flatten"
 
+  // private[this] modifiers on classes need be widened before lifting the class
+  override def runsAfter = Set(ElimLocals.name)
+
   override def changesMembers = true // the phase removes inner classes
 
   private var LiftedDefs: Store.Location[mutable.ListBuffer[Tree]] = _

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

@@ -54,7 +54,7 @@ class Getters extends MiniPhase with SymTransformer {
   override def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = {
     def noGetterNeeded =
       d.is(NoGetterNeeded) ||
-      d.initial.asInstanceOf[SymDenotation].is(PrivateLocal) && !d.owner.is(Trait) && !isDerivedValueClass(d.owner) && !d.is(Flags.Lazy) ||
+      d.is(PrivateLocal) && !d.owner.is(Trait) && !isDerivedValueClass(d.owner) && !d.is(Flags.Lazy) ||
       d.is(Module) && d.isStatic ||
       d.hasAnnotation(defn.ScalaStaticAnnot) ||
       d.isSelfSym

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

@@ -0,0 +1,15 @@
+object A1 {
+  private[this] class B
+
+  private[this] class C {
+    def cons: B = new B
+  }
+}
+
+class A2 {
+  private[this] class B
+
+  private[this] class C {
+    def cons: B = new B
+  }
+}

tests/pos/flatten.scala

@@ -0,0 +1,15 @@
+class StringOps(val s: String) extends AnyVal {
+  def lines: Iterator[String] = new collection.AbstractIterator[String] {
+    private[this] var index = 0
+    def hasNext: Boolean = false
+    def next(): String = {
+      index = 1
+      ""
+    }
+  }
+}
+
+class FooOps(val s: String) extends AnyVal {
+  private[this] def bar = 2
+  def foo = bar
+}