make private[this] if possible

Author: xuwei-k

src/compiler/scala/tools/nsc/settings/MutableSettings.scala

@@ -358,17 +358,17 @@ class MutableSettings(val errorFn: String => Unit)
    */
   abstract class Setting(val name: String, val helpDescription: String) extends AbsSetting with SettingValue {
     /** Will be called after this Setting is set for any extra work. */
-    private var _postSetHook: this.type => Unit = (x: this.type) => ()
+    private[this] var _postSetHook: this.type => Unit = (x: this.type) => ()
     override def postSetHook(): Unit = _postSetHook(this)
     def withPostSetHook(f: this.type => Unit): this.type = { _postSetHook = f ; this }
 
     /** The syntax defining this setting in a help string */
-    private var _helpSyntax = name
+    private[this] var _helpSyntax = name
     override def helpSyntax: String = _helpSyntax
     def withHelpSyntax(s: String): this.type    = { _helpSyntax = s ; this }
 
     /** Abbreviations for this setting */
-    private var _abbreviations: List[String] = Nil
+    private[this] var _abbreviations: List[String] = Nil
     override def abbreviations = _abbreviations
     def withAbbreviation(s: String): this.type  = { _abbreviations ++= List(s) ; this }
 
@@ -377,7 +377,7 @@ class MutableSettings(val errorFn: String => Unit)
     override def dependencies = dependency.toList
     def dependsOn(s: Setting, value: String): this.type = { dependency = Some((s, value)); this }
 
-    private var _deprecationMessage: Option[String] = None
+    private[this] var _deprecationMessage: Option[String] = None
     override def deprecationMessage = _deprecationMessage
     def withDeprecationMessage(msg: String): this.type = { _deprecationMessage = Some(msg) ; this }
   }

src/compiler/scala/tools/nsc/transform/patmat/Logic.scala

@@ -151,7 +151,7 @@ trait Logic extends Debugging  {
         val newSym = new Sym(variable, const)
         (uniques findEntryOrUpdate newSym)
       }
-      def nextSymId = {_symId += 1; _symId}; private var _symId = 0
+      def nextSymId = {_symId += 1; _symId}; private[this] var _symId = 0
       implicit val SymOrdering: Ordering[Sym] = Ordering.by(_.id)
     }
 
@@ -506,7 +506,7 @@ trait ScalaLogic extends Interface with Logic with TreeAndTypeAnalysis {
     def prepareNewAnalysis(): Unit = { Var.resetUniques(); Const.resetUniques() }
 
     object Var extends VarExtractor {
-      private var _nextId = 0
+      private[this] var _nextId = 0
       def nextId = {_nextId += 1; _nextId}
 
       def resetUniques() = {_nextId = 0; uniques.clear()}
@@ -722,10 +722,10 @@ trait ScalaLogic extends Interface with Logic with TreeAndTypeAnalysis {
     object Const {
       def resetUniques() = {_nextTypeId = 0; _nextValueId = 0; uniques.clear() ; trees.clear()}
 
-      private var _nextTypeId = 0
+      private[this] var _nextTypeId = 0
       def nextTypeId = {_nextTypeId += 1; _nextTypeId}
 
-      private var _nextValueId = 0
+      private[this] var _nextValueId = 0
       def nextValueId = {_nextValueId += 1; _nextValueId}
 
       private val uniques = new mutable.HashMap[Type, Const]

src/compiler/scala/tools/nsc/typechecker/Contexts.scala

@@ -256,7 +256,7 @@ trait Contexts { self: Analyzer =>
       */
     var enclMethod: Context = _
 
-    private var _undetparams: List[Symbol] = List()
+    private[this] var _undetparams: List[Symbol] = List()
 
     protected def outerDepth = if (outerIsNoContext) 0 else outer.depth
 

src/library/scala/collection/View.scala

@@ -194,9 +194,9 @@ object View extends IterableFactory[View] {
   @SerialVersionUID(3L)
   class LeftPartitionedWith[A, A1, A2](partitionWith: PartitionWith[A, A1, A2], f: A => Either[A1, A2]) extends AbstractView[A1] {
     def iterator = new AbstractIterator[A1] {
-      private val self = partitionWith.underlying.iterator
-      private var hd: A1 = _
-      private var hdDefined: Boolean = false
+      private[this] val self = partitionWith.underlying.iterator
+      private[this] var hd: A1 = _
+      private[this] var hdDefined: Boolean = false
       def hasNext = hdDefined || {
         def findNext(): Boolean =
           if (self.hasNext) {
@@ -218,9 +218,9 @@ object View extends IterableFactory[View] {
   @SerialVersionUID(3L)
   class RightPartitionedWith[A, A1, A2](partitionWith: PartitionWith[A, A1, A2], f: A => Either[A1, A2]) extends AbstractView[A2] {
       def iterator = new AbstractIterator[A2] {
-        private val self = partitionWith.underlying.iterator
-        private var hd: A2 = _
-        private var hdDefined: Boolean = false
+        private[this] val self = partitionWith.underlying.iterator
+        private[this] var hd: A2 = _
+        private[this] var hdDefined: Boolean = false
         def hasNext = hdDefined || {
           def findNext(): Boolean =
             if (self.hasNext) {

src/library/scala/collection/immutable/Map.scala

@@ -249,7 +249,7 @@ object Map extends MapFactory[Map] {
     }
 
     private abstract class Map2Iterator[A] extends AbstractIterator[A] {
-      var i = 0
+      private[this] var i = 0
       override def hasNext: Boolean = i < 2
       override def next(): A = {
         val result = i match {
@@ -306,7 +306,7 @@ object Map extends MapFactory[Map] {
     }
 
     private abstract class Map3Iterator[A] extends AbstractIterator[A] {
-      var i = 0
+      private[this] var i = 0
       override def hasNext: Boolean = i < 3
       override def next(): A = {
         val result = i match {
@@ -369,7 +369,7 @@ object Map extends MapFactory[Map] {
     }
 
     private abstract class Map4Iterator[A] extends AbstractIterator[A] {
-      var i = 0
+      private[this] var i = 0
       override def hasNext: Boolean = i < 4
       override def next(): A = {
         val result = i match {

src/library/scala/util/control/NoStackTrace.scala

@@ -29,6 +29,6 @@ object NoStackTrace {
   final def noSuppression = _noSuppression
 
   // two-stage init to make checkinit happy, since sys.SystemProperties.noTraceSuppression.value calls back into NoStackTrace.noSuppression
-  final private var _noSuppression = false
+  final private[this] var _noSuppression = false
   _noSuppression = System.getProperty("scala.control.noTraceSuppression", "").equalsIgnoreCase("true")
 }

src/reflect/scala/reflect/internal/AnnotationCheckers.scala

@@ -80,7 +80,7 @@ trait AnnotationCheckers {
   // Syncnote: Annotation checkers inaccessible to reflection, so no sync in var necessary.
 
   /** The list of annotation checkers that have been registered */
-  private var annotationCheckers: List[AnnotationChecker] = Nil
+  private[this] var annotationCheckers: List[AnnotationChecker] = Nil
 
   /** Register an annotation checker.  Typically these are added by compiler plugins. */
   def addAnnotationChecker(checker: AnnotationChecker): Unit = {

src/reflect/scala/reflect/internal/AnnotationInfos.scala

@@ -144,7 +144,7 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable =>
     assert(args.isEmpty || assocs.isEmpty, atp)
 
     // necessary for reification, see Reifiers.scala for more info
-    private var orig: Tree = EmptyTree
+    private[this] var orig: Tree = EmptyTree
     def original = orig
     def setOriginal(t: Tree): this.type = {
       orig = t
@@ -166,7 +166,7 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable =>
    *  definitions) have to be lazy (#1782)
    */
   final class LazyAnnotationInfo(lazyInfo: => AnnotationInfo) extends AnnotationInfo {
-    private var forced = false
+    private[this] var forced = false
     private lazy val forcedInfo = try lazyInfo finally forced = true
 
     def atp: Type                               = forcedInfo.atp
@@ -215,7 +215,7 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable =>
     // see annotationArgRewriter
     lazy val isTrivial = atp.isTrivial && !hasArgWhich(_.isInstanceOf[This])
 
-    private var rawpos: Position = NoPosition
+    private[this] var rawpos: Position = NoPosition
     def pos = rawpos
     def setPos(pos: Position): this.type = { // Syncnote: Setpos inaccessible to reflection, so no sync in rawpos necessary.
       rawpos = pos

src/reflect/scala/reflect/internal/BaseTypeSeqs.scala

@@ -61,7 +61,7 @@ trait BaseTypeSeqs {
     // (while NoType is in there to indicate a cycle in this BTS, during the execution of
     //  the mergePrefixAndArgs below, the elems get copied without the pending map,
     //  so that NoType's are seen instead of the original type --> spurious compile error)
-    private val pending = new mutable.BitSet(length)
+    private[this] val pending = new mutable.BitSet(length)
 
     /** The type at i'th position in this sequence; lazy types are returned evaluated. */
     def apply(i: Int): Type =

src/reflect/scala/reflect/internal/Definitions.scala

@@ -47,7 +47,7 @@ trait Definitions extends api.StandardDefinitions {
 
     import ClassfileConstants._
 
-    private val nameToWeight = Map[Name, Int](
+    private[this] val nameToWeight = Map[Name, Int](
       tpnme.Byte   -> 2,
       tpnme.Char   -> 3,
       tpnme.Short  -> 4,
@@ -57,7 +57,7 @@ trait Definitions extends api.StandardDefinitions {
       tpnme.Double -> 96
     )
 
-    private val nameToTag = Map[Name, Char](
+    private[this] val nameToTag = Map[Name, Char](
       tpnme.Byte    -> BYTE_TAG,
       tpnme.Char    -> CHAR_TAG,
       tpnme.Short   -> SHORT_TAG,
@@ -178,7 +178,7 @@ trait Definitions extends api.StandardDefinitions {
   }
 
   abstract class DefinitionsClass extends DefinitionsApi with ValueClassDefinitions {
-    private var isInitialized = false
+    private[this] var isInitialized = false
     def isDefinitionsInitialized = isInitialized
 
     // It becomes tricky to create dedicated objects for other symbols because
@@ -588,10 +588,10 @@ trait Definitions extends api.StandardDefinitions {
       (sym.tpe member nme.main).alternatives exists isJavaMainMethod
 
     class VarArityClass(name: String, maxArity: Int, countFrom: Int = 0, init: Option[ClassSymbol] = None) extends VarArityClassApi {
-      private val offset = countFrom - init.size
+      private[this] val offset = countFrom - init.size
       private def isDefinedAt(i: Int) = i < seq.length + offset && i >= offset
       val seq: IndexedSeq[ClassSymbol] = (init ++: countFrom.to(maxArity).map { i => getRequiredClass("scala." + name + i) }).toVector
-      private val symSet = new SymbolSet(seq.toList)
+      private[this] val symSet = new SymbolSet(seq.toList)
       def contains(sym: Symbol): Boolean = symSet.contains(sym)
       def apply(i: Int) = if (isDefinedAt(i)) seq(i - offset) else NoSymbol
       def specificType(args: List[Type], others: Type*): Type = {

src/reflect/scala/reflect/internal/Flags.scala

@@ -379,8 +379,8 @@ class Flags extends ModifierFlags {
     (ABSTRACT, ABSTRACT_PKL)
   )
 
-  private val mappedRawFlags = rawPickledCorrespondence map (_._1)
-  private val mappedPickledFlags = rawPickledCorrespondence map (_._2)
+  private[this] val mappedRawFlags = rawPickledCorrespondence map (_._1)
+  private[this] val mappedPickledFlags = rawPickledCorrespondence map (_._2)
 
   private class MapFlags(from: Array[Long], to: Array[Long]) extends (Long => Long) {
     val fromSet = from.foldLeft(0L) (_ | _)

src/reflect/scala/reflect/internal/Names.scala

@@ -28,17 +28,17 @@ trait Names extends api.Names {
   //
   // Discussion: https://groups.google.com/forum/#!search/biased$20scala-internals/scala-internals/0cYB7SkJ-nM/47MLhsgw8jwJ
   protected def synchronizeNames: Boolean = false
-  private val nameLock: Object = new Object
+  private[this] val nameLock: Object = new Object
 
   /** Memory to store all names sequentially. */
   var chrs: Array[Char] = new Array[Char](NAME_SIZE)
-  private var nc = 0
+  private[this] var nc = 0
 
   /** Hashtable for finding term names quickly. */
-  private val termHashtable = new Array[TermName](HASH_SIZE)
+  private[this] val termHashtable = new Array[TermName](HASH_SIZE)
 
   /** Hashtable for finding type names quickly. */
-  private val typeHashtable = new Array[TypeName](HASH_SIZE)
+  private[this] val typeHashtable = new Array[TypeName](HASH_SIZE)
 
   /**
    * The hashcode of a name depends on the first, the last and the middle character,

src/reflect/scala/reflect/internal/Positions.scala

@@ -128,7 +128,7 @@ trait Positions extends api.Positions { self: SymbolTable =>
     throw new ValidateException(msg)
   }
 
-  private val posStartOrdering: Ordering[Tree] = new Ordering[Tree] {
+  private[this] val posStartOrdering: Ordering[Tree] = new Ordering[Tree] {
     override def compare(x: Tree, y: Tree): Int = {
       @inline def posOf(t: Tree): Int = {
         val pos = t.pos

src/reflect/scala/reflect/internal/Precedence.scala

@@ -12,7 +12,7 @@ final class Precedence private (val level: Int) extends AnyVal with Ordered[Prec
 
 
 object Precedence extends (Int => Precedence) {
-  private val ErrorName = "<error>"
+  private[this] val ErrorName = "<error>"
   private def isAssignmentOp(name: String) = name match {
     case "!=" | "<=" | ">=" | "" => false
     case _                       => name.last == '=' && name.head != '=' && isOperatorPart(name.head)

src/reflect/scala/reflect/internal/Printers.scala

@@ -202,8 +202,8 @@ trait Printers extends api.Printers { self: SymbolTable =>
       annots foreach (annot => print(s"@$annot "))
     }
 
-    private var currentOwner: Symbol = NoSymbol
-    private var selectorType: Type = NoType
+    private[this] var currentOwner: Symbol = NoSymbol
+    private[this] var selectorType: Type = NoType
 
     protected def printPackageDef(tree: PackageDef, separator: String) = {
       val PackageDef(packaged, stats) = tree
@@ -1139,18 +1139,18 @@ trait Printers extends api.Printers { self: SymbolTable =>
   private class Footnotes {
     import scala.collection.mutable.{Map, WeakHashMap, SortedSet}
 
-    private val index = Map[Class[_], WeakHashMap[Any, Int]]()
+    private[this] val index = Map[Class[_], WeakHashMap[Any, Int]]()
     private def classIndex[T: ClassTag] = index.getOrElseUpdate(classTag[T].runtimeClass, WeakHashMap[Any, Int]())
 
-    private val counters = Map[Class[_], Int]()
+    private[this] val counters = Map[Class[_], Int]()
     private def nextCounter[T: ClassTag] = {
       val clazz = classTag[T].runtimeClass
       counters.getOrElseUpdate(clazz, 0)
       counters(clazz) = counters(clazz) + 1
       counters(clazz)
     }
 
-    private val footnotes = Map[Class[_], SortedSet[Int]]()
+    private[this] val footnotes = Map[Class[_], SortedSet[Int]]()
     private def classFootnotes[T: ClassTag] = footnotes.getOrElseUpdate(classTag[T].runtimeClass, SortedSet[Int]())
 
     def put[T: ClassTag](any: T): Int = {
@@ -1177,10 +1177,10 @@ trait Printers extends api.Printers { self: SymbolTable =>
 
   // emits more or less verbatim representation of the provided tree
   class RawTreePrinter(out: PrintWriter) extends super.TreePrinter {
-    private var depth = 0
-    private var printTypesInFootnotes = true
-    private var printingFootnotes = false
-    private val footnotes = new Footnotes()
+    private[this] var depth = 0
+    private[this] var printTypesInFootnotes = true
+    private[this] var printingFootnotes = false
+    private[this] val footnotes = new Footnotes()
 
     def print(args: Any*): Unit = {
       // don't print type footnotes if the argument is a mere type

src/reflect/scala/reflect/internal/Scopes.scala

@@ -73,8 +73,8 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
 
     /** a cache for all elements, to be used by symbol iterator.
      */
-    private var elemsCache: List[Symbol] = null
-    private var cachedSize = -1
+    private[this] var elemsCache: List[Symbol] = null
+    private[this] var cachedSize = -1
     private def flushElemsCache(): Unit = {
       elemsCache = null
       cachedSize = -1
@@ -275,13 +275,13 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
     /** Returns an iterator yielding every symbol with given name in this scope.
      */
     def lookupAll(name: Name): Iterator[Symbol] = new AbstractIterator[Symbol] {
-      var e = lookupEntry(name)
+      private[this] var e = lookupEntry(name)
       def hasNext: Boolean = e ne null
       def next(): Symbol = try e.sym finally e = lookupNextEntry(e)
     }
 
     def lookupAllEntries(name: Name): Iterator[ScopeEntry] = new AbstractIterator[ScopeEntry] {
-      var e = lookupEntry(name)
+      private[this] var e = lookupEntry(name)
       def hasNext: Boolean = e ne null
       def next(): ScopeEntry = try e finally e = lookupNextEntry(e)
     }

src/reflect/scala/reflect/internal/StdNames.scala

@@ -31,7 +31,7 @@ trait StdNames {
    *  CommonNames constructor out of the starting gate.  This is its builder.
    */
   private class KeywordSetBuilder {
-    private var kws: Set[TermName] = Set()
+    private[this] var kws: Set[TermName] = Set()
     def apply(s: String): TermName = {
       val result = newTermNameCached(s)
       kws = kws + result
@@ -168,7 +168,7 @@ trait StdNames {
   /** This should be the first trait in the linearization. */
   // abstract class Keywords extends CommonNames {
   abstract class Keywords extends {
-    private val kw = new KeywordSetBuilder
+    private[this] val kw = new KeywordSetBuilder
 
     final val ABSTRACTkw: TermName  = kw("abstract")
     final val CASEkw: TermName      = kw("case")
@@ -1120,7 +1120,7 @@ trait StdNames {
   }
 
   class JavaKeywords {
-    private val kw = new KeywordSetBuilder
+    private[this] val kw = new KeywordSetBuilder
 
     final val ABSTRACTkw: TermName     = kw("abstract")
     final val ASSERTkw: TermName       = kw("assert")