chore: migrate syntaxic changes in the stdlib

Author: hamzaremmal

library/src/scala/App.scala

@@ -73,9 +73,9 @@ trait App extends DelayedInit {
    */
   protected final def args: Array[String] = _args
 
-  private[this] var _args: Array[String] = _
+  private var _args: Array[String] = compiletime.uninitialized
 
-  private[this] val initCode = new ListBuffer[() => Unit]
+  private 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.

library/src/scala/Array.scala

@@ -152,7 +152,7 @@ object Array {
     *
     * @see `java.util.Arrays#copyOf`
     */
-  def copyAs[A](original: Array[_], newLength: Int)(implicit ct: ClassTag[A]): Array[A] = {
+  def copyAs[A](original: Array[?], newLength: Int)(implicit ct: ClassTag[A]): Array[A] = {
     val runtimeClass = ct.runtimeClass
     if (runtimeClass == Void.TYPE) newUnitArray(newLength).asInstanceOf[Array[A]]
     else {

library/src/scala/Console.scala

@@ -126,9 +126,9 @@ import scala.util.DynamicVariable
  *
  */
 object Console extends AnsiColor {
-  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](
+  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](
     new BufferedReader(new InputStreamReader(java.lang.System.in)))
 
   protected def setOutDirect(out: PrintStream): Unit  = outVar.value = out
@@ -279,5 +279,5 @@ object Console extends AnsiColor {
    *  @throws java.lang.IllegalArgumentException if there was a problem with the format string or arguments
    *  @group console-output
    */
-  def printf(text: String, args: Any*): Unit = { out.print(text.format(args: _*)) }
+  def printf(text: String, args: Any*): Unit = { out.print(text.format(args*)) }
 }

library/src/scala/Enumeration.scala

@@ -99,8 +99,12 @@ abstract class Enumeration (initial: Int) extends Serializable {
   /** The name of this enumeration.
    */
   override def toString: String =
-    ((getClass.getName stripSuffix MODULE_SUFFIX_STRING split '.').last split
-       Regex.quote(NAME_JOIN_STRING)).last
+    getClass.getName
+      .stripSuffix(MODULE_SUFFIX_STRING)
+      .split('.')
+      .last 
+      .split(Regex.quote(NAME_JOIN_STRING))
+      .last
 
   /** The mapping from the integer used to identify values to the actual
     * values. */
@@ -112,7 +116,7 @@ abstract class Enumeration (initial: Int) extends Serializable {
 
   /** The mapping from the integer used to identify values to their
     * names. */
-  private[this] val nmap: mutable.Map[Int, String] = new mutable.HashMap
+  private val nmap: mutable.Map[Int, String] = new mutable.HashMap
 
   /** The values of this enumeration as a set.
    */
@@ -128,18 +132,18 @@ abstract class Enumeration (initial: Int) extends Serializable {
   protected var nextId: Int = initial
 
   /** The string to use to name the next created value. */
-  protected var nextName: Iterator[String] = _
+  protected var nextName: Iterator[String] = compiletime.uninitialized
 
   private def nextNameOrNull: String | Null =
     if (nextName != null && nextName.hasNext) nextName.next() else null
 
   /** The highest integer amongst those used to identify values in this
     * enumeration. */
-  private[this] var topId = initial
+  private var topId = initial
 
   /** The lowest integer amongst those used to identify values in this
     * enumeration, but no higher than 0. */
-  private[this] var bottomId = if(initial < 0) initial else 0
+  private var bottomId = if(initial < 0) initial else 0
 
   /** The one higher than the highest integer amongst those used to identify
     *  values in this enumeration. */
@@ -190,7 +194,7 @@ abstract class Enumeration (initial: Int) extends Serializable {
   protected final def Value(i: Int, name: String | Null): Value = new Val(i, name)
 
   private def populateNameMap(): Unit = {
-    @tailrec def getFields(clazz: Class[_] | Null, acc: Array[JField]): Array[JField] = {
+    @tailrec def getFields(clazz: Class[?] | Null, acc: Array[JField]): Array[JField] = {
       if (clazz == null)
         acc
       else
@@ -285,7 +289,7 @@ abstract class Enumeration (initial: Int) extends Serializable {
    *  @define Coll `collection.immutable.SortedSet`
    */
   @SerialVersionUID(7229671200427364242L)
-  class ValueSet private[ValueSet] (private[this] var nnIds: immutable.BitSet)
+  class ValueSet private[ValueSet] (private var nnIds: immutable.BitSet)
     extends immutable.AbstractSet[Value]
       with immutable.SortedSet[Value]
       with immutable.SortedSetOps[Value, immutable.SortedSet, ValueSet]
@@ -341,7 +345,7 @@ abstract class Enumeration (initial: Int) extends Serializable {
     def fromBitMask(elems: Array[Long]): ValueSet = new ValueSet(immutable.BitSet.fromBitMask(elems))
     /** A builder object for value sets */
     def newBuilder: mutable.Builder[Value, ValueSet] = new mutable.Builder[Value, ValueSet] {
-      private[this] val b = new mutable.BitSet
+      private val b = new mutable.BitSet
       def addOne (x: Value) = { b += (x.id - bottomId); this }
       def clear() = b.clear()
       def result() = new ValueSet(b.toImmutable)

library/src/scala/MatchError.scala

@@ -22,7 +22,7 @@ final class MatchError(@transient obj: Any) extends RuntimeException {
   /** There's no reason we need to call toString eagerly,
    *  so defer it until getMessage is called or object is serialized
    */
-  private[this] lazy val objString: String = {
+  private lazy val objString: String = {
     def ofClass = "of class " + obj.getClass.getName
     if (obj == null) "null"
     else

library/src/scala/PartialFunction.scala

@@ -341,7 +341,7 @@ object PartialFunction {
    *
    *  Here `fallback_fn` is used as both unique marker object and special fallback function that returns it.
    */
-  private[this] val fallback_fn: Any -> Any = _ => fallback_fn
+  private val fallback_fn: Any -> Any = _ => fallback_fn
   private def checkFallback[B] = fallback_fn.asInstanceOf[Any => B]
   private def fallbackOccurred[B](x: B) = fallback_fn eq x.asInstanceOf[AnyRef]
 
@@ -376,9 +376,9 @@ object PartialFunction {
    */
   def fromFunction[A, B](f: A => B): PartialFunction[A, B]^{f} = { case x => f(x) }
 
-  private[this] val constFalse: Any -> Boolean = { _ => false}
+  private val constFalse: Any -> Boolean = { _ => false}
 
-  private[this] val empty_pf: PartialFunction[Any, Nothing] = new PartialFunction[Any, Nothing] with Serializable {
+  private val empty_pf: PartialFunction[Any, Nothing] = new PartialFunction[Any, Nothing] with Serializable {
     def isDefinedAt(x: Any) = false
     def apply(x: Any) = throw new MatchError(x)
     override def orElse[A1, B1](that: PartialFunction[A1, B1]^) = that

library/src/scala/Predef.scala

@@ -498,7 +498,7 @@ object Predef extends LowPriorityImplicits {
    *  @see [[scala.StringContext.f StringContext.f]]
    *  @group console-output
    */
-  def printf(text: String, xs: Any*): Unit = Console.print(text.format(xs: _*))
+  def printf(text: String, xs: Any*): Unit = Console.print(text.format(xs*))
 
   // views --------------------------------------------------------------
 

library/src/scala/Product.scala

@@ -38,8 +38,8 @@ transparent trait Product extends Any with Equals {
    *  @return     in the default implementation, an `Iterator[Any]`
    */
   def productIterator: Iterator[Any] = new scala.collection.AbstractIterator[Any] {
-    private[this] var c: Int = 0
-    private[this] val cmax = productArity
+    private var c: Int = 0
+    private val cmax = productArity
     def hasNext: Boolean = c < cmax
     def next(): Any = { val result = productElement(c); c += 1; result }
   }
@@ -66,8 +66,8 @@ transparent trait Product extends Any with Equals {
   /** An iterator over the names of all the elements of this product.
    */
   def productElementNames: Iterator[String] = new scala.collection.AbstractIterator[String] {
-    private[this] var c: Int = 0
-    private[this] val cmax = productArity
+    private var c: Int = 0
+    private val cmax = productArity
     def hasNext: Boolean = c < cmax
     def next(): String = { val result = productElementName(c); c += 1; result }
   }

library/src/scala/Proxy.scala

@@ -34,7 +34,7 @@ trait Proxy extends Any {
     case null  => false
     case _     =>
       val x = that.asInstanceOf[AnyRef]
-      (x eq this.asInstanceOf[AnyRef]) || (x eq self.asInstanceOf[AnyRef]) || (x equals self)
+      (x eq this.asInstanceOf[AnyRef]) || (x eq self.asInstanceOf[AnyRef]) || (x.equals(self))
   }
   override def toString = "" + self
 }

library/src/scala/StringContext.scala

@@ -313,7 +313,7 @@ object StringContext {
     s"""invalid unicode escape at index $index of $str"""
   )
 
-  private[this] def readUEscape(src: String, startindex: Int): (Char, Int) = {
+  private def readUEscape(src: String, startindex: Int): (Char, Int) = {
     val len = src.length()
     def loop(uindex: Int): (Char, Int) = {
       def loopCP(dindex: Int, codepoint: Int): (Char, Int) = {
@@ -362,19 +362,19 @@ object StringContext {
    *  @return The string with all escape sequences expanded.
    */
   def processEscapes(str: String): String =
-    str indexOf '\\' match {
+    str.indexOf('\\') match {
       case -1 => str
       case  i => replace(str, i)
     }
 
   protected[scala] def processUnicode(str: String): String =
-    str indexOf "\\u" match {
+    str.indexOf("\\u") match {
       case -1 => str
       case i  => replaceU(str, i)
     }
 
   //replace escapes with given first escape
-  private[this] def replace(str: String, first: Int): String = {
+  private def replace(str: String, first: Int): String = {
     val len = str.length()
     val b = new JLSBuilder
     // append replacement starting at index `i`, with `next` backslash
@@ -399,7 +399,7 @@ object StringContext {
           val (ch, advance) = if (c == 'u') readUEscape(str, idx)
                               else (c, 1)
           idx += advance
-          b append ch
+          b.append(ch)
           loop(idx, str.indexOf('\\', idx))
         } else {
           if (i < len) b.append(str, i, len)
@@ -423,7 +423,7 @@ object StringContext {
    * Otherwise, the backslash is not taken to introduce an escape and the
    * backslash is taken to be literal
    */
-  private[this] def replaceU(str: String, backslash: Int): String = {
+  private def replaceU(str: String, backslash: Int): String = {
     val len = str.length()
     val b = new JLSBuilder
 
@@ -458,8 +458,8 @@ object StringContext {
     val ai = args.iterator
     val bldr = new JLSBuilder(process(pi.next()))
     while (ai.hasNext) {
-      bldr append ai.next()
-      bldr append process(pi.next())
+      bldr.append(ai.next())
+      bldr.append(process(pi.next()))
     }
     bldr.toString
   }