Merge pull request #7411 from dotty-staging/drop-local

Infer private[this]

Author: anatoliykmetyuk

compiler/src/dotty/tools/backend/WorklistAlgorithm.scala

@@ -19,7 +19,7 @@ import scala.collection.mutable
 trait WorklistAlgorithm {
   type Elem
   class WList {
-    private[this] var list: List[Elem] = Nil
+    private var list: List[Elem] = Nil
     def isEmpty = list.isEmpty
     def nonEmpty = !isEmpty
     def push(e: Elem): Unit = { list = e :: list }

compiler/src/dotty/tools/backend/jvm/CoreBTypes.scala

@@ -203,7 +203,7 @@ final class CoreBTypesProxy[BTFS <: BTypesFromSymbols[_ <: BackendInterface]](va
   import bTypes._
   import bTypes.int._
 
-  private[this] var _coreBTypes: CoreBTypes[bTypes.type] = _
+  private var _coreBTypes: CoreBTypes[bTypes.type] = _
   def setBTypes(coreBTypes: CoreBTypes[BTFS]): Unit = {
     _coreBTypes = coreBTypes.asInstanceOf[CoreBTypes[bTypes.type]]
   }

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -39,7 +39,7 @@ class GenBCode extends Phase {
     superCallsMap.update(sym, old + calls)
   }
 
-  private[this] var myOutput: AbstractFile = _
+  private var myOutput: AbstractFile = _
 
   private def outputDir(implicit ctx: Context): AbstractFile = {
     if (myOutput eq null)
@@ -68,14 +68,14 @@ object GenBCode {
 
 class GenBCodePipeline(val int: DottyBackendInterface)(implicit val ctx: Context) extends BCodeSyncAndTry {
 
-  private[this] var tree: Tree = _
+  private var tree: Tree = _
 
-  private[this] val sourceFile: SourceFile = ctx.compilationUnit.source
+  private val sourceFile: SourceFile = ctx.compilationUnit.source
 
   /** Convert a `dotty.tools.io.AbstractFile` into a
    *  `dotty.tools.dotc.interfaces.AbstractFile`.
    */
-  private[this] def convertAbstractFile(absfile: dotty.tools.io.AbstractFile): interfaces.AbstractFile =
+  private def convertAbstractFile(absfile: dotty.tools.io.AbstractFile): interfaces.AbstractFile =
     new interfaces.AbstractFile {
       override def name = absfile.name
       override def path = absfile.path
@@ -86,8 +86,8 @@ class GenBCodePipeline(val int: DottyBackendInterface)(implicit val ctx: Context
 
 //  class BCodePhase() {
 
-  private[this] var bytecodeWriter  : BytecodeWriter   = null
-  private[this] var mirrorCodeGen   : JMirrorBuilder   = null
+  private var bytecodeWriter  : BytecodeWriter   = null
+  private var mirrorCodeGen   : JMirrorBuilder   = null
 
   /* ---------------- q1 ---------------- */
 

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -82,7 +82,7 @@ class JSCodeGen()(implicit ctx: Context) {
   /* See genSuperCall()
    * TODO Can we avoid this unscoped var?
    */
-  private[this] var isModuleInitialized: Boolean = false
+  private var isModuleInitialized: Boolean = false
 
   private def currentClassType = encodeClassType(currentClassSym)
 

compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala

@@ -173,7 +173,7 @@ final class JSDefinitions()(implicit ctx: Context) {
     @threadUnsafe lazy val Reflect_registerInstantiatableClassR = ReflectModule.requiredMethodRef("registerInstantiatableClass")
     def Reflect_registerInstantiatableClass(implicit ctx: Context) = Reflect_registerInstantiatableClassR.symbol
 
-  private[this] var allRefClassesCache: Set[Symbol] = _
+  private var allRefClassesCache: Set[Symbol] = _
   def allRefClasses(implicit ctx: Context): Set[Symbol] = {
     if (allRefClassesCache == null) {
       val baseNames = List("Object", "Boolean", "Character", "Byte", "Short",

compiler/src/dotty/tools/backend/sjs/JSPositions.scala

@@ -35,11 +35,11 @@ class JSPositions()(implicit ctx: Context) {
   implicit def implicitSourcePos2irPos(implicit sourcePos: SourcePosition): ir.Position =
     sourceAndSpan2irPos(sourcePos.source, sourcePos.span)
 
-  private[this] object span2irPosCache { // scalastyle:ignore
+  private object span2irPosCache { // scalastyle:ignore
     import dotty.tools.dotc.util._
 
-    private[this] var lastDotcSource: SourceFile = null
-    private[this] var lastIRSource: ir.Position.SourceFile = null
+    private var lastDotcSource: SourceFile = null
+    private var lastIRSource: ir.Position.SourceFile = null
 
     def toIRSource(dotcSource: SourceFile): ir.Position.SourceFile = {
       if (dotcSource != lastDotcSource) {
@@ -49,7 +49,7 @@ class JSPositions()(implicit ctx: Context) {
       lastIRSource
     }
 
-    private[this] def convert(dotcSource: SourceFile): ir.Position.SourceFile = {
+    private def convert(dotcSource: SourceFile): ir.Position.SourceFile = {
       dotcSource.file.file match {
         case null =>
           new java.net.URI(

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

@@ -12,7 +12,7 @@ import scala.annotation.internal.sharable
  */
 object Bench extends Driver {
 
-  @sharable private[this] var numRuns = 1
+  @sharable private var numRuns = 1
 
   private def ntimes(n: Int)(op: => Reporter): Reporter =
     (0 until n).foldLeft(emptyReporter)((_, _) => op)

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

@@ -39,7 +39,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    *                 for type checking.
    *    imports      For each element of RootImports, an import context
    */
-  protected[this] def rootContext(implicit ctx: Context): Context = {
+  protected def rootContext(implicit ctx: Context): Context = {
     ctx.initialize()(ctx)
     ctx.base.setPhasePlan(comp.phases)
     val rootScope = new MutableScope
@@ -59,19 +59,19 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     defn.RootImportFns.foldLeft(start.setRun(this))(addImport)
   }
 
-  private[this] var compiling = false
+  private var compiling = false
 
-  private[this] var myCtx = rootContext(ictx)
+  private var myCtx = rootContext(ictx)
 
   /** The context created for this run */
   def runContext: Context = myCtx
 
-  protected[this] implicit def ctx: Context = myCtx
+  protected implicit def ctx: Context = myCtx
   assert(ctx.runId <= Periods.MaxPossibleRunId)
 
-  private[this] var myUnits: List[CompilationUnit] = _
-  private[this] var myUnitsCached: List[CompilationUnit] = _
-  private[this] var myFiles: Set[AbstractFile] = _
+  private var myUnits: List[CompilationUnit] = _
+  private var myUnitsCached: List[CompilationUnit] = _
+  private var myFiles: Set[AbstractFile] = _
 
   /** The compilation units currently being compiled, this may return different
     *  results over time.
@@ -94,10 +94,10 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   }
 
   /** The source files of all late entered symbols, as a set */
-  private[this] var lateFiles = mutable.Set[AbstractFile]()
+  private var lateFiles = mutable.Set[AbstractFile]()
 
   /** Actions that need to be performed at the end of the current compilation run */
-  private[this] var finalizeActions = mutable.ListBuffer[() => Unit]()
+  private var finalizeActions = mutable.ListBuffer[() => Unit]()
 
   def compile(fileNames: List[String]): Unit = try {
     val sources = fileNames.map(ctx.getSource(_))

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

@@ -150,12 +150,14 @@ object desugar {
    *  ==>
    *    def x: Int = expr
    *    def x_=($1: <TypeTree()>): Unit = ()
+   *
+   *  Generate the setter only for non-private class members and all trait members.
    */
   def valDef(vdef0: ValDef)(implicit ctx: Context): Tree = {
     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/ast/PluggableTransformers.scala

@@ -9,8 +9,8 @@ object PluggableTransformers {
   abstract class PluggableTransformer[T] extends TreeTransformer[T, Context] {
     type PluginOp[-N <: Tree[T]] = N => Tree[T]
 
-    private[this] var _ctx: Context = _
-    private[this] var _oldTree: Tree[T] = _
+    private var _ctx: Context = _
+    private var _oldTree: Tree[T] = _
 
     protected implicit def ctx: Context = _ctx
     protected def oldTree: Tree[T] = _oldTree
@@ -44,7 +44,7 @@ object PluggableTransformers {
 
     val EmptyPlugin = new Plugins
 
-    private[this] var _plugins: Plugins = EmptyPlugin
+    private var _plugins: Plugins = EmptyPlugin
 
     override def plugins: Plugins = _plugins