make private[this] if possible

private (not private[this]) val and var generate accessor methods.
This change reduce class file size

Author: xuwei-k

src/library/scala/App.scala

@@ -45,9 +45,9 @@ trait App extends DelayedInit {
    */
   protected final def args: Array[String] = _args
 
-  private var _args: Array[String] = _
+  private[this] var _args: Array[String] = _
 
-  private val initCode = new ListBuffer[() => Unit]
+  private[this] val initCode = new ListBuffer[() => Unit]
 
   /** The init hook. This saves all initialization code for execution within `main`.
    *  This method is normally never called directly from user code.

src/library/scala/Console.scala

@@ -123,9 +123,9 @@ import scala.util.DynamicVariable
  *
  */
 object Console extends AnsiColor {
-  private val outVar = new DynamicVariable[PrintStream](java.lang.System.out)
-  private val errVar = new DynamicVariable[PrintStream](java.lang.System.err)
-  private val inVar  = new DynamicVariable[BufferedReader](
+  private[this] val outVar = new DynamicVariable[PrintStream](java.lang.System.out)
+  private[this] val errVar = new DynamicVariable[PrintStream](java.lang.System.err)
+  private[this] val inVar  = new DynamicVariable[BufferedReader](
     new BufferedReader(new InputStreamReader(java.lang.System.in)))
 
   protected def setOutDirect(out: PrintStream): Unit  = outVar.value = out

src/library/scala/Enumeration.scala

@@ -99,7 +99,7 @@ abstract class Enumeration (initial: Int) extends Serializable {
 
   /** The mapping from the integer used to identify values to their
     * names. */
-  private val nmap: mutable.Map[Int, String] = new mutable.HashMap
+  private[this] val nmap: mutable.Map[Int, String] = new mutable.HashMap
 
   /** The values of this enumeration as a set.
    */
@@ -122,11 +122,11 @@ abstract class Enumeration (initial: Int) extends Serializable {
 
   /** The highest integer amongst those used to identify values in this
     * enumeration. */
-  private var topId = initial
+  private[this] var topId = initial
 
   /** The lowest integer amongst those used to identify values in this
     * enumeration, but no higher than 0. */
-  private var bottomId = if(initial < 0) initial else 0
+  private[this] var bottomId = if(initial < 0) initial else 0
 
   /** The one higher than the highest integer amongst those used to identify
     *  values in this enumeration. */

src/library/scala/Product.scala

@@ -36,8 +36,8 @@ trait Product extends Any with Equals {
    *  @return     in the default implementation, an `Iterator[Any]`
    */
   def productIterator: Iterator[Any] = new scala.collection.AbstractIterator[Any] {
-    private var c: Int = 0
-    private val cmax = productArity
+    private[this] var c: Int = 0
+    private[this] val cmax = productArity
     def hasNext = c < cmax
     def next() = { val result = productElement(c); c += 1; result }
   }

src/library/scala/Symbol.scala

@@ -45,10 +45,10 @@ private[scala] abstract class UniquenessCache[K, V >: Null]
   import java.util.WeakHashMap
   import java.util.concurrent.locks.ReentrantReadWriteLock
 
-  private val rwl = new ReentrantReadWriteLock()
-  private val rlock = rwl.readLock
-  private val wlock = rwl.writeLock
-  private val map = new WeakHashMap[K, WeakReference[V]]
+  private[this] val rwl = new ReentrantReadWriteLock()
+  private[this] val rlock = rwl.readLock
+  private[this] val wlock = rwl.writeLock
+  private[this] val map = new WeakHashMap[K, WeakReference[V]]
 
   protected def valueFromKey(k: K): V
   protected def keyFromValue(v: V): Option[K]

src/library/scala/collection/BitSet.scala

@@ -97,8 +97,8 @@ trait BitSetOps[+C <: BitSet with BitSetOps[C]]
   def iterator: Iterator[Int] = iteratorFrom(0)
 
   def iteratorFrom(start: Int): Iterator[Int] = new AbstractIterator[Int] {
-    private var current = start
-    private val end = nwords * WordLength
+    private[this] var current = start
+    private[this] val end = nwords * WordLength
     def hasNext: Boolean = {
       while (current != end && !self.contains(current)) current += 1
       current != end

src/library/scala/collection/IndexedSeq.scala

@@ -17,7 +17,7 @@ trait IndexedSeqOps[+A, +CC[_], +C] extends Any with SeqOps[A, CC, C] { self =>
   def iterator: Iterator[A] = view.iterator
 
   override def reverseIterator: Iterator[A] = new AbstractIterator[A] {
-    private var i = self.length
+    private[this] var i = self.length
     def hasNext: Boolean = 0 < i
     def next(): A =
       if (0 < i) {

src/library/scala/collection/IndexedSeqView.scala

@@ -23,7 +23,7 @@ object IndexedSeqView {
 
   @SerialVersionUID(3L)
   private final class IndexedSeqViewIterator[A](self: IndexedSeqView[A]) extends AbstractIterator[A] with Serializable {
-    private var current = 0
+    private[this] var current = 0
     override def knownSize: Int = self.size - current
     def hasNext = current < self.size
     def next(): A = {

src/library/scala/collection/Iterator.scala

@@ -103,8 +103,8 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
     *  @note    Reuse: $consumesAndProducesIterator
     */
   def buffered: BufferedIterator[A] = new AbstractIterator[A] with BufferedIterator[A] {
-    private var hd: A = _
-    private var hdDefined: Boolean = false
+    private[this] var hd: A = _
+    private[this] var hdDefined: Boolean = false
 
     def head: A = {
       if (!hdDefined) {
@@ -308,13 +308,13 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
   def scanLeft[B](z: B)(op: (B, A) => B): Iterator[B] = new AbstractIterator[B] {
     // We use an intermediate iterator that iterates through the first element `z`
     // and then that will be modified to iterate through the collection
-    private var current: Iterator[B] =
+    private[this] var current: Iterator[B] =
       new AbstractIterator[B] {
         def hasNext: Boolean = true
         def next(): B = {
           // Here we change our self-reference to a new iterator that iterates through `self`
           current = new AbstractIterator[B] {
-            private var acc = z
+            private[this] var acc = z
             def next(): B = {
               acc = op(acc, self.next())
               acc
@@ -381,8 +381,8 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
   def filterNot(p: A => Boolean): Iterator[A] = filterImpl(p, isFlipped = true)
 
   private[collection] def filterImpl(p: A => Boolean, isFlipped: Boolean): Iterator[A] = new AbstractIterator[A] {
-    private var hd: A = _
-    private var hdDefined: Boolean = false
+    private[this] var hd: A = _
+    private[this] var hdDefined: Boolean = false
 
     def hasNext: Boolean = hdDefined || {
       do {
@@ -457,9 +457,9 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
     */
   def distinctBy[B](f: A => B): Iterator[A] = new AbstractIterator[A] {
 
-    private val traversedValues = mutable.HashSet.empty[B]
-    private var nextElementDefined: Boolean = false
-    private var nextElement: A = _
+    private[this] val traversedValues = mutable.HashSet.empty[B]
+    private[this] var nextElementDefined: Boolean = false
+    private[this] var nextElement: A = _
 
     def hasNext: Boolean = {
       @tailrec
@@ -496,7 +496,7 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
   }
 
   def flatMap[B](f: A => IterableOnce[B]): Iterator[B] = new AbstractIterator[B] {
-    private var myCurrent: Iterator[B] = Iterator.empty
+    private[this] var myCurrent: Iterator[B] = Iterator.empty
     private def current = {
       while (!myCurrent.hasNext && self.hasNext)
         myCurrent = f(self.next()).iterator
@@ -514,7 +514,7 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
   @`inline` final def ++ [B >: A](xs: => IterableOnce[B]): Iterator[B] = concat(xs)
 
   def take(n: Int): Iterator[A] = new AbstractIterator[A] {
-    private var i = 0
+    private[this] var i = 0
     def hasNext = self.hasNext && i < n
     def next() =
       if (hasNext) {
@@ -525,9 +525,9 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
   }
 
   def takeWhile(p: A => Boolean): Iterator[A] = new AbstractIterator[A] {
-    private var hd: A = _
-    private var hdDefined: Boolean = false
-    private var tail: Iterator[A] = self
+    private[this] var hd: A = _
+    private[this] var hdDefined: Boolean = false
+    private[this] var tail: Iterator[A] = self
 
     def hasNext = hdDefined || tail.hasNext && {
       hd = tail.next()
@@ -779,8 +779,8 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
     */
   def patch[B >: A](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B] =
     new AbstractIterator[B] {
-      private var origElems = self
-      private var i = if (from > 0) from else 0 // Counts down, switch to patch on 0, -1 means use patch first
+      private[this] var origElems = self
+      private[this] var i = if (from > 0) from else 0 // Counts down, switch to patch on 0, -1 means use patch first
       def hasNext: Boolean = {
         if (i == 0) {
           origElems = origElems drop replaced
@@ -841,7 +841,7 @@ object Iterator extends IterableFactory[Iterator] {
   @`inline` final def empty[T]: Iterator[T] = _empty
 
   def single[A](a: A): Iterator[A] = new AbstractIterator[A] {
-    private var consumed: Boolean = false
+    private[this] var consumed: Boolean = false
     def hasNext = !consumed
     def next() = if (consumed) empty.next() else { consumed = true; a }
   }
@@ -864,7 +864,7 @@ object Iterator extends IterableFactory[Iterator] {
     *  @return  An iterator that produces the results of `n` evaluations of `elem`.
     */
   override def fill[A](len: Int)(elem: => A): Iterator[A] = new AbstractIterator[A] {
-    private var i = 0
+    private[this] var i = 0
     def hasNext: Boolean = i < len
     def next(): A =
       if (hasNext) { i += 1; elem }
@@ -878,7 +878,7 @@ object Iterator extends IterableFactory[Iterator] {
     *  @return An iterator that produces the values `f(0), ..., f(n -1)`.
     */
   override def tabulate[A](end: Int)(f: Int => A): Iterator[A] = new AbstractIterator[A] {
-    private var i = 0
+    private[this] var i = 0
     def hasNext: Boolean = i < end
     def next(): A =
       if (hasNext) { val result = f(i); i += 1; result }
@@ -899,7 +899,7 @@ object Iterator extends IterableFactory[Iterator] {
     *  @return      the iterator producing the infinite sequence of values `start, start + 1 * step, start + 2 * step, ...`
     */
   def from(start: Int, step: Int): Iterator[Int] = new AbstractIterator[Int] {
-    private var i = start
+    private[this] var i = start
     def hasNext: Boolean = true
     def next(): Int = { val result = i; i += step; result }
   }
@@ -921,8 +921,8 @@ object Iterator extends IterableFactory[Iterator] {
     */
   def range(start: Int, end: Int, step: Int): Iterator[Int] = new AbstractIterator[Int] {
     if (step == 0) throw new IllegalArgumentException("zero step")
-    private var i = start
-    private var hasOverflowed = false
+    private[this] var i = start
+    private[this] var hasOverflowed = false
     def hasNext: Boolean = {
       (step <= 0 || i < end) && (step >= 0 || i > end) && !hasOverflowed
     }
@@ -1045,8 +1045,8 @@ object Iterator extends IterableFactory[Iterator] {
     *  Lazily skip to start on first evaluation.  Avoids daisy-chained iterators due to slicing.
     */
   private[scala] final class SliceIterator[A](val underlying: Iterator[A], start: Int, limit: Int) extends AbstractIterator[A] {
-    private var remaining = limit
-    private var dropping  = start
+    private[this] var remaining = limit
+    private[this] var dropping  = start
     @inline private def unbounded = remaining < 0
     private def skip(): Unit =
       while (dropping > 0) {