Add mapNull and nullForGC to ScalaRunTime

Author: noti0na1

library-js/src/scala/runtime/ScalaRunTime.scala

@@ -252,11 +252,14 @@ object ScalaRunTime {
       case s => s + "\n"
     }
 
+
   // For backward compatibility with code compiled without -Yexplicit-nulls.
   // If `a` is null, return null; otherwise, return `f`.
-  // Have to add a private mapNull here to avoid errors
-  private inline def mapNull[A, B](a: A, inline f: B): B =
-    if((a: A | Null) == null) null.asInstanceOf[B] else f
+  private[scala] inline def mapNull[A, B](a: A, inline f: B): B =
+    if ((a: A | Null) == null) null.asInstanceOf[B] else f
+
+  // Use `null` in places where we want to make sure the reference is cleared.
+  private[scala] inline def nullForGC[T]: T = null.asInstanceOf[T]
 
   // For the following functions, both the parameter and the return type are non-nullable.
   // However, if a null reference is passed explicitly, this method will still return null.
@@ -266,11 +269,8 @@ object ScalaRunTime {
   // Convert arrays to immutable.ArraySeq for use with Java varargs:
   def genericWrapArray[T](xs: Array[T]): ArraySeq[T] =
     mapNull(xs, ArraySeq.unsafeWrapArray(xs))
-  def wrapRefArray[T <: AnyRef | Null](xs: Array[T]): ArraySeq[T] = {
-    if (xs eq null) null.asInstanceOf[ArraySeq[T]]
-    else if (xs.length == 0) ArraySeq.empty[AnyRef].asInstanceOf[ArraySeq[T]]
-    else new ArraySeq.ofRef[T](xs)
-  }
+  def wrapRefArray[T <: AnyRef | Null](xs: Array[T]): ArraySeq[T] =
+    mapNull(xs, if (xs.length == 0) ArraySeq.empty[AnyRef].asInstanceOf[ArraySeq[T]] else new ArraySeq.ofRef[T](xs))
   def wrapIntArray(xs: Array[Int]): ArraySeq[Int] = mapNull(xs, new ArraySeq.ofInt(xs))
   def wrapDoubleArray(xs: Array[Double]): ArraySeq[Double] = mapNull(xs, new ArraySeq.ofDouble(xs))
   def wrapLongArray(xs: Array[Long]): ArraySeq[Long] = mapNull(xs, new ArraySeq.ofLong(xs))

library/src/scala/IArray.scala

@@ -332,9 +332,9 @@ object IArray:
 
   // For backward compatibility with code compiled without -Yexplicit-nulls.
   // If `a` is null, return null; otherwise, return `f`.
-  // Have to add a private mapNull here to avoid errors
+  // Have to add a private mapNull here to avoid errors, use `ScalaRunTime.mapNull` in the future.
   private inline def mapNull[A, B](a: A, inline f: B): B =
-    if((a: A | Null) == null) null.asInstanceOf[B] else f
+    if ((a: A | Null) == null) null.asInstanceOf[B] else f
 
   // For the following functions, both the parameter and the return type are non-nullable.
   // However, if a null reference is passed explicitly, this method will still return null.

library/src/scala/Predef.scala

@@ -20,6 +20,7 @@ import scala.annotation.{elidable, experimental, implicitNotFound, publicInBinar
 import scala.annotation.meta.{ companionClass, companionMethod }
 import scala.annotation.internal.{ RuntimeChecked }
 import scala.compiletime.summonFrom
+import scala.runtime.ScalaRunTime.mapNull
 
 /** The `Predef` object provides definitions that are accessible in all Scala
  *  compilation units without explicit qualification.
@@ -597,14 +598,6 @@ object Predef extends LowPriorityImplicits {
     @experimental
     inline def fromNullable[T](t: T | Null): Option[T] = Option(t).asInstanceOf[Option[T]]
 
-  // For backward compatibility with code compiled without -Yexplicit-nulls.
-  // If `a` is null, return null; otherwise, return `f`.
-  private[scala] inline def mapNull[A, B](a: A, inline f: B): B =
-    if((a: A | Null) == null) null.asInstanceOf[B] else f
-
-  // Use `null` in places where we want to make sure the reference is cleared.
-  private[scala] inline def nullForGC[T]: T = null.asInstanceOf[T]
-
   /** A type supporting Self-based type classes.
    *
    *    A is TC

library/src/scala/collection/Iterator.scala

@@ -17,6 +17,7 @@ import language.experimental.captureChecking
 import scala.collection.mutable.{ArrayBuffer, ArrayBuilder, Builder, ImmutableBuilder}
 import scala.annotation.tailrec
 import scala.annotation.unchecked.uncheckedVariance
+import scala.runtime.ScalaRunTime.nullForGC
 import scala.runtime.Statics
 
 /** Iterators are data structures that allow to iterate over a sequence
@@ -772,14 +773,14 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
         case 1 => if (self.hasNext) { status = 2 ; true } else { status = 3 ; false }
         case 0 => true
         case _ =>
-          if (myLeading.finish()) { status = 0 ; true } else { status = 1 ; myLeading = null.asInstanceOf[Leading]; hasNext }
+          if (myLeading.finish()) { status = 0 ; true } else { status = 1 ; myLeading = nullForGC[Leading]; hasNext }
       }
       def next() = {
         if (hasNext) {
           if (status == 0) {
             status = 1
             val res = myLeading.trailer
-            myLeading = null.asInstanceOf[Leading]
+            myLeading = nullForGC[Leading]
             res
           } else {
             status = 1
@@ -1301,7 +1302,7 @@ object Iterator extends IterableFactory[Iterator] {
           if (res eq null) throw new NullPointerException("null during unfold")
           res
         }
-        state = null.asInstanceOf[S] // allow GC
+        state = nullForGC[S]
       }
       nextResult.nn.isDefined
     }

library/src/scala/collection/SeqView.scala

@@ -18,6 +18,7 @@ import language.experimental.captureChecking
 
 import scala.annotation.nowarn
 import scala.collection.generic.CommonErrors
+import scala.runtime.ScalaRunTime.nullForGC
 
 
 trait SeqView[+A] extends SeqOps[A, View, View[A]] with View[A] {
@@ -187,7 +188,7 @@ object SeqView {
         }
       }
       evaluated = true
-      underlying = nullForGC[SomeSeqOps[A]] // allow GC of unneeded reference
+      underlying = nullForGC[SomeSeqOps[A]]
       res
     }
 

library/src/scala/collection/View.scala

@@ -18,6 +18,7 @@ import language.experimental.captureChecking
 import scala.annotation.{nowarn, tailrec}
 import scala.collection.mutable.{ArrayBuffer, Builder}
 import scala.collection.immutable.LazyList
+import scala.runtime.ScalaRunTime.nullForGC
 import caps.unsafe.unsafeAssumePure
 
 /** Views are collections whose transformation operations are non strict: the resulting elements
@@ -465,7 +466,7 @@ object View extends IterableFactory[View] {
         if(pos == maxlen) pos = 0
         len += 1
       }
-      underlying = null.asInstanceOf[Iterator[A]] // allow GC of underlying iterator
+      underlying = nullForGC[Iterator[A]]
       if(len > maxlen) len = maxlen
       pos = pos - len
       if(pos < 0) pos += maxlen

library/src/scala/collection/immutable/Stream.scala

@@ -23,6 +23,8 @@ import scala.annotation.unchecked.uncheckedVariance
 import scala.collection.generic.SerializeEnd
 import scala.collection.mutable.{ArrayBuffer, StringBuilder}
 import scala.language.implicitConversions
+import scala.runtime.ScalaRunTime.nullForGC
+
 import Stream.cons
 
 @deprecated("Use LazyListIterable (which is fully lazy) instead of Stream (which has a lazy tail only)", "2.13.0")

library/src/scala/collection/immutable/Vector.scala

@@ -27,7 +27,7 @@ import scala.collection.generic.{CommonErrors, DefaultSerializable}
 import scala.collection.immutable.VectorInline._
 import scala.collection.immutable.VectorStatics._
 import scala.collection.mutable.ReusableBuilder
-
+import scala.runtime.ScalaRunTime.nullForGC
 
 /** $factoryInfo
   * @define Coll `Vector`
@@ -1421,11 +1421,11 @@ final class VectorBuilder[A] extends ReusableBuilder[A, Vector[A]] {
   @inline def nonEmpty: Boolean = knownSize != 0
 
   def clear(): Unit = {
-    a6 = null.asInstanceOf[Arr6]
-    a5 = null.asInstanceOf[Arr5]
-    a4 = null.asInstanceOf[Arr4]
-    a3 = null.asInstanceOf[Arr3]
-    a2 = null.asInstanceOf[Arr2]
+    a6 = nullForGC[Arr6]
+    a5 = nullForGC[Arr5]
+    a4 = nullForGC[Arr4]
+    a3 = nullForGC[Arr3]
+    a2 = nullForGC[Arr2]
     a1 = new Arr1(WIDTH)
     len1 = 0
     lenRest = 0

library/src/scala/runtime/ScalaRunTime.scala

@@ -54,7 +54,7 @@ object ScalaRunTime {
     classTag[T].runtimeClass.asInstanceOf[jClass[T]]
 
   /** Retrieve generic array element */
-  def array_apply(xs: AnyRef | Null, idx: Int): Any = {
+  def array_apply(xs: AnyRef, idx: Int): Any = {
     (xs: @unchecked) match {
       case x: Array[AnyRef]  => x(idx).asInstanceOf[Any]
       case x: Array[Int]     => x(idx).asInstanceOf[Any]
@@ -70,7 +70,7 @@ object ScalaRunTime {
   }
 
   /** update generic array element */
-  def array_update(xs: AnyRef | Null, idx: Int, value: Any): Unit = {
+  def array_update(xs: AnyRef, idx: Int, value: Any): Unit = {
     (xs: @unchecked) match {
       case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
       case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
@@ -86,11 +86,11 @@ object ScalaRunTime {
   }
 
   /** Get generic array length */
-  @inline def array_length(xs: AnyRef | Null): Int = java.lang.reflect.Array.getLength(xs)
+  @inline def array_length(xs: AnyRef): Int = java.lang.reflect.Array.getLength(xs)
 
   // TODO: bytecode Object.clone() will in fact work here and avoids
   // the type switch. See Array_clone comment in BCodeBodyBuilder.
-  def array_clone(xs: AnyRef | Null): AnyRef = (xs: @unchecked) match {
+  def array_clone(xs: AnyRef): AnyRef = (xs: @unchecked) match {
     case x: Array[AnyRef]  => x.clone()
     case x: Array[Int]     => x.clone()
     case x: Array[Double]  => x.clone()
@@ -107,7 +107,7 @@ object ScalaRunTime {
    *  Needed to deal with vararg arguments of primitive types that are passed
    *  to a generic Java vararg parameter T ...
    */
-  def toObjectArray(src: AnyRef | Null): Array[Object] = {
+  def toObjectArray(src: AnyRef): Array[Object] = {
     def copy[@specialized T <: AnyVal](src: Array[T]): Array[Object] = {
       val length = src.length
       if (length == 0) Array.emptyObjectArray
@@ -281,6 +281,14 @@ object ScalaRunTime {
       case s => s + "\n"
     }
 
+  // For backward compatibility with code compiled without -Yexplicit-nulls.
+  // If `a` is null, return null; otherwise, return `f`.
+  private[scala] inline def mapNull[A, B](a: A, inline f: B): B =
+    if ((a: A | Null) == null) null.asInstanceOf[B] else f
+
+  // Use `null` in places where we want to make sure the reference is cleared.
+  private[scala] inline def nullForGC[T]: T = null.asInstanceOf[T]
+
   // Convert arrays to immutable.ArraySeq for use with Scala varargs.
   // By construction, calls to these methods always receive a fresh (and non-null), non-empty array.
   // In cases where an empty array would appear, the compiler uses a direct reference to Nil instead.

library/src/scala/util/Using.scala

@@ -14,6 +14,7 @@ package scala.util
 
 import scala.language.`2.13`
 import scala.util.control.{ControlThrowable, NonFatal}
+import scala.runtime.ScalaRunTime.nullForGC
 
 /** A utility for performing automatic resource management. It can be used to perform an
   * operation using resources, after which it releases the resources in reverse order
@@ -208,7 +209,7 @@ object Using {
       } finally {
         closed = true
         var rs = resources
-        resources = null.asInstanceOf[List[Resource[_]]] // allow GC, in case something is holding a reference to `this`
+        resources = nullForGC[List[Resource[_]]] // allow GC, in case something is holding a reference to `this`
         while (rs != null && rs.nonEmpty) {
           val resource = rs.head
           rs = rs.tail