Adjust some type parameters

Author: noti0na1

library/src/scala/Array.scala

@@ -586,7 +586,7 @@ object Array {
     def get: UnapplySeqWrapper[T] = this
     def lengthCompare(len: Int): Int = a.lengthCompare(len)
     def apply(i: Int): T = a(i)
-    def drop(n: Int): scala.Seq[T] = ArraySeq.unsafeWrapArray(a.drop(n)) // clones the array, also if n == 0
+    def drop(n: Int): scala.Seq[T] = ArraySeq.unsafeWrapArray(a.drop(n)).nn // clones the array, also if n == 0
     def toSeq: scala.Seq[T] = a.toSeq // clones the array
   }
 }

library/src/scala/IArray.scala

@@ -332,19 +332,19 @@ object IArray:
 
   // For backwards compatibility with code compiled without -Yexplicit-nulls
   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
 
   /** Conversion from IArray to immutable.ArraySeq */
   implicit def genericWrapArray[T](arr: IArray[T]): ArraySeq[T] =
-    mapNull(arr, ArraySeq.unsafeWrapArray(arr))
+    mapNull(arr, ArraySeq.unsafeWrapArray(arr)).asInstanceOf[ArraySeq[T]]
 
   /** Conversion from IArray to immutable.ArraySeq */
-  implicit def wrapRefArray[T <: AnyRef](arr: IArray[T]): ArraySeq.ofRef[T] =
-    // Since the JVM thinks arrays are covariant, one 0-length Array[AnyRef]
-    // is as good as another for all T <: AnyRef.  Instead of creating 100,000,000
+  implicit def wrapRefArray[T <: AnyRef | Null](arr: IArray[T]): ArraySeq.ofRef[T] =
+    // Since the JVM thinks arrays are covariant, one 0-length Array[AnyRef | Null]
+    // is as good as another for all T <: AnyRef | Null.  Instead of creating 100,000,000
     // unique ones by way of this implicit, let's share one.
     mapNull(arr,
-      if (arr.length == 0) ArraySeq.empty[AnyRef].asInstanceOf[ArraySeq.ofRef[T]]
+      if (arr.length == 0) ArraySeq.empty[AnyRef | Null].asInstanceOf[ArraySeq.ofRef[T]]
       else ArraySeq.ofRef(arr.asInstanceOf[Array[T]])
     )
 

library/src/scala/Predef.scala

@@ -657,47 +657,49 @@ private[scala] abstract class LowPriorityImplicits extends LowPriorityImplicits2
   @inline implicit def doubleWrapper(x: Double): runtime.RichDouble    = new runtime.RichDouble(x)
   @inline implicit def booleanWrapper(x: Boolean): runtime.RichBoolean = new runtime.RichBoolean(x)
 
+  // For backwards compatibility with code compiled without -Yexplicit-nulls
+  private inline def mapNull[A, B](a: A, inline f: B): B =
+    if((a: A | Null) == null) null.asInstanceOf[B] else f
+
   /** @group conversions-array-to-wrapped-array */
-  implicit def genericWrapArray[T](xs: Array[T] | Null): ArraySeq[T] | Null =
-    if (xs eq null) null
-    else ArraySeq.make(xs)
+  implicit def genericWrapArray[T](xs: Array[T]): ArraySeq[T] =
+    mapNull(xs, ArraySeq.make(xs))
 
   // Since the JVM thinks arrays are covariant, one 0-length Array[AnyRef]
   // is as good as another for all T <: AnyRef.  Instead of creating 100,000,000
   // unique ones by way of this implicit, let's share one.
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapRefArray[T <: AnyRef](xs: Array[T] | Null): ArraySeq.ofRef[T] | Null = {
-    if (xs eq null) null
-    else if (xs.length == 0) ArraySeq.empty[AnyRef].asInstanceOf[ArraySeq.ofRef[T]]
-    else new ArraySeq.ofRef[T](xs)
-  }
+  implicit def wrapRefArray[T <: AnyRef | Null](xs: Array[T]): ArraySeq.ofRef[T] =
+    mapNull(xs,
+      if (xs.length == 0) ArraySeq.empty[AnyRef].asInstanceOf[ArraySeq.ofRef[T]]
+      else new ArraySeq.ofRef[T](xs))
 
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapIntArray(xs: Array[Int] | Null): ArraySeq.ofInt | Null = if (xs ne null) new ArraySeq.ofInt(xs) else null
+  implicit def wrapIntArray(xs: Array[Int]): ArraySeq.ofInt = mapNull(xs, new ArraySeq.ofInt(xs))
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapDoubleArray(xs: Array[Double] | Null): ArraySeq.ofDouble | Null = if (xs ne null) new ArraySeq.ofDouble(xs) else null
+  implicit def wrapDoubleArray(xs: Array[Double]): ArraySeq.ofDouble = mapNull(xs, new ArraySeq.ofDouble(xs))
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapLongArray(xs: Array[Long] | Null): ArraySeq.ofLong | Null = if (xs ne null) new ArraySeq.ofLong(xs) else null
+  implicit def wrapLongArray(xs: Array[Long]): ArraySeq.ofLong = mapNull(xs, new ArraySeq.ofLong(xs))
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapFloatArray(xs: Array[Float] | Null): ArraySeq.ofFloat | Null = if (xs ne null) new ArraySeq.ofFloat(xs) else null
+  implicit def wrapFloatArray(xs: Array[Float]): ArraySeq.ofFloat = mapNull(xs, new ArraySeq.ofFloat(xs))
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapCharArray(xs: Array[Char] | Null): ArraySeq.ofChar | Null = if (xs ne null) new ArraySeq.ofChar(xs) else null
+  implicit def wrapCharArray(xs: Array[Char]): ArraySeq.ofChar = mapNull(xs, new ArraySeq.ofChar(xs))
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapByteArray(xs: Array[Byte] | Null): ArraySeq.ofByte | Null = if (xs ne null) new ArraySeq.ofByte(xs) else null
+  implicit def wrapByteArray(xs: Array[Byte]): ArraySeq.ofByte = mapNull(xs, new ArraySeq.ofByte(xs))
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapShortArray(xs: Array[Short] | Null): ArraySeq.ofShort | Null = if (xs ne null) new ArraySeq.ofShort(xs) else null
+  implicit def wrapShortArray(xs: Array[Short]): ArraySeq.ofShort = mapNull(xs, new ArraySeq.ofShort(xs))
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapBooleanArray(xs: Array[Boolean] | Null): ArraySeq.ofBoolean | Null = if (xs ne null) new ArraySeq.ofBoolean(xs) else null
+  implicit def wrapBooleanArray(xs: Array[Boolean]): ArraySeq.ofBoolean = mapNull(xs, new ArraySeq.ofBoolean(xs))
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapUnitArray(xs: Array[Unit] | Null): ArraySeq.ofUnit | Null = if (xs ne null) new ArraySeq.ofUnit(xs) else null
+  implicit def wrapUnitArray(xs: Array[Unit]): ArraySeq.ofUnit = mapNull(xs, new ArraySeq.ofUnit(xs))
 
   /** @group conversions-string */
-  implicit def wrapString(s: String | Null): WrappedString | Null = if (s ne null) new WrappedString(s) else null
+  implicit def wrapString(s: String): WrappedString = mapNull(s, new WrappedString(s))
 }
 
 private[scala] abstract class LowPriorityImplicits2 {
   @deprecated("implicit conversions from Array to immutable.IndexedSeq are implemented by copying; use `toIndexedSeq` explicitly if you want to copy, or use the more efficient non-copying ArraySeq.unsafeWrapArray", since="2.13.0")
-  implicit def copyArrayToImmutableIndexedSeq[T](xs: Array[T] | Null): IndexedSeq[T] | Null =
-    if (xs eq null) null
+  implicit def copyArrayToImmutableIndexedSeq[T](xs: Array[T]): IndexedSeq[T] =
+    if (xs eq null) null.asInstanceOf[IndexedSeq[T]]
     else new ArrayOps(xs).toIndexedSeq
 }

library/src/scala/StringContext.scala

@@ -293,7 +293,7 @@ object StringContext {
     // Matched all of pattern to all of name. Success.
     Some(collection.immutable.ArraySeq.unsafeWrapArray(
       Array.tabulate(patternChunks.length - 1)(n => input.slice(matchStarts(n), matchEnds(n)))
-    ))
+    ).nn)
   }
 
   /** An exception that is thrown if a string contains a backslash (`\`) character
@@ -475,3 +475,4 @@ object StringContext {
         +") for interpolated string with "+ parts.length +" parts")
 
 }
+

library/src/scala/Symbol.scala

@@ -36,7 +36,7 @@ object Symbol extends UniquenessCache[String, Symbol] {
 
 /** This is private so it won't appear in the library API, but
   * abstracted to offer some hope of reusability.  */
-private[scala] abstract class UniquenessCache[K, V >: Null] {
+private[scala] abstract class UniquenessCache[K, V] {
   import java.lang.ref.WeakReference
   import java.util.WeakHashMap
   import java.util.concurrent.locks.ReentrantReadWriteLock
@@ -50,7 +50,7 @@ private[scala] abstract class UniquenessCache[K, V >: Null] {
   protected def keyFromValue(v: V): Option[K]
 
   def apply(name: K): V = {
-    def cached(): V = {
+    def cached(): V | Null = {
       rlock.lock
       try {
         val reference = map get name

library/src/scala/collection/ArrayOps.scala

@@ -60,7 +60,7 @@ object ArrayOps {
   private class ArrayView[A](xs: Array[A]) extends AbstractIndexedSeqView[A] {
     def length = xs.length
     def apply(n: Int) = xs(n)
-    override def toString: String = immutable.ArraySeq.unsafeWrapArray(xs).mkString("ArrayView(", ", ", ")")
+    override def toString: String = immutable.ArraySeq.unsafeWrapArray(xs).nn.mkString("ArrayView(", ", ", ")")
   }
 
   /** A lazy filtered array. No filtering is applied until one of `foreach`, `map` or `flatMap` is called. */
@@ -429,7 +429,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal {
     val s = (shape.shape: @unchecked) match {
       case StepperShape.ReferenceShape => (xs: Any) match {
         case bs: Array[Boolean] => new BoxedBooleanArrayStepper(bs, 0, xs.length)
-        case _ => new ObjectArrayStepper[AnyRef](xs.asInstanceOf[Array[AnyRef ]], 0, xs.length)
+        case _ => new ObjectArrayStepper[AnyRef](xs.asInstanceOf[Array[AnyRef]], 0, xs.length)
       }
       case StepperShape.IntShape    => new IntArrayStepper           (xs.asInstanceOf[Array[Int    ]], 0, xs.length)
       case StepperShape.LongShape   => new LongArrayStepper          (xs.asInstanceOf[Array[Long   ]], 0, xs.length)
@@ -1084,7 +1084,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal {
     * @return a decorator `LazyZip2` that allows strict operations to be performed on the lazily evaluated pairs
     *         or chained calls to `lazyZip`. Implicit conversion to `Iterable[(A, B)]` is also supported.
     */
-  def lazyZip[B](that: Iterable[B]^): LazyZip2[A, B, Array[A]]^{that} = new LazyZip2(xs, immutable.ArraySeq.unsafeWrapArray(xs), that)
+  def lazyZip[B](that: Iterable[B]^): LazyZip2[A, B, Array[A]]^{that} = new LazyZip2(xs, immutable.ArraySeq.unsafeWrapArray(xs).nn, that)
 
   /** Returns an array formed from this array and another iterable collection
     *  by combining corresponding elements in pairs.
@@ -1438,7 +1438,7 @@ final class ArrayOps[A](private val xs: Array[A]) extends AnyVal {
   @`inline` final def toSeq: immutable.Seq[A] = toIndexedSeq
 
   def toIndexedSeq: immutable.IndexedSeq[A] =
-    immutable.ArraySeq.unsafeWrapArray(Array.copyOf(xs, xs.length))
+    immutable.ArraySeq.unsafeWrapArray(Array.copyOf(xs, xs.length)).nn
 
   /** Copy elements of this array to another array.
     *  Fills the given array `xs` starting at index 0.

library/src/scala/collection/SeqView.scala

@@ -138,7 +138,7 @@ object SeqView {
     extends SeqView[A] {
     outer: Sorted[A, B]^ =>
 
-    private var underlying = underlying_
+    private var underlying: SomeSeqOps[A] | Null = underlying_
 
     // force evaluation immediately by calling `length` so infinite collections
     // hang on `sorted`/`sortWith`/`sortBy` rather than on arbitrary method calls
@@ -169,10 +169,10 @@ object SeqView {
       val res = {
         val len = this.len
         if (len == 0) Nil
-        else if (len == 1) List(underlying.head)
+        else if (len == 1) List(underlying.nn.head)
         else {
           val arr = new Array[Any](len) // Array[Any] =:= Array[AnyRef]
-          @annotation.unused val copied = underlying.copyToArray(arr)
+          @annotation.unused val copied = underlying.nn.copyToArray(arr)
           //assert(copied == len)
           java.util.Arrays.sort(arr.asInstanceOf[Array[AnyRef]], ord.asInstanceOf[Ordering[AnyRef]])
           // casting the Array[AnyRef] to Array[A] and creating an ArraySeq from it
@@ -183,7 +183,7 @@ object SeqView {
           //     contains items of another type, we'd get a CCE anyway)
           //   - the cast doesn't actually do anything in the runtime because the
           //     type of A is not known and Array[_] is Array[AnyRef]
-          immutable.ArraySeq.unsafeWrapArray(arr.asInstanceOf[Array[A]])
+          immutable.ArraySeq.unsafeWrapArray(arr.asInstanceOf[Array[A]]).nn
         }
       }
       evaluated = true
@@ -192,7 +192,7 @@ object SeqView {
     }
 
     private[this] def elems: SomeSeqOps[A]^{this} = {
-      val orig: SomeSeqOps[A]^{this} = underlying
+      val orig: SomeSeqOps[A]^{this} = underlying.nn
       if (evaluated) _sorted else orig
     }
 

library/src/scala/collection/View.scala

@@ -459,13 +459,13 @@ object View extends IterableFactory[View] {
       len = 0
       while(underlying.hasNext) {
         val n = underlying.next().asInstanceOf[AnyRef]
-        if(pos >= buf.length) buf.addOne(n)
-        else buf(pos) = n
+        if(pos >= buf.nn.length) buf.nn.addOne(n)
+        else buf.nn(pos) = n
         pos += 1
         if(pos == maxlen) pos = 0
         len += 1
       }
-      underlying = null
+      underlying = null.asInstanceOf[Iterator[A]^] // allow GC of underlying iterator
       if(len > maxlen) len = maxlen
       pos = pos - len
       if(pos < 0) pos += maxlen
@@ -479,7 +479,7 @@ object View extends IterableFactory[View] {
       init()
       if(len == 0) Iterator.empty.next()
       else {
-        val x = buf(pos).asInstanceOf[A]
+        val x = buf.nn(pos).asInstanceOf[A]
         pos += 1
         if(pos == maxlen) pos = 0
         len -= 1
@@ -513,7 +513,7 @@ object View extends IterableFactory[View] {
     def init(): Unit = if(buf eq null) {
       buf = new ArrayBuffer[AnyRef](maxlen min 256)
       while(pos < maxlen && underlying.hasNext) {
-        buf.addOne(underlying.next().asInstanceOf[AnyRef])
+        buf.nn.addOne(underlying.next().asInstanceOf[AnyRef])
         pos += 1
       }
       if(!underlying.hasNext) len = 0
@@ -527,9 +527,9 @@ object View extends IterableFactory[View] {
     def next(): A = {
       if(!hasNext) Iterator.empty.next()
       else {
-        val x = buf(pos).asInstanceOf[A]
+        val x = buf.nn(pos).asInstanceOf[A]
         if(len == -1) {
-          buf(pos) = underlying.next().asInstanceOf[AnyRef]
+          buf.nn(pos) = underlying.next().asInstanceOf[AnyRef]
           if(!underlying.hasNext) len = 0
         } else len -= 1
         pos += 1

library/src/scala/collection/convert/StreamExtensions.scala

@@ -303,7 +303,7 @@ trait StreamExtensions {
       if (info.companion == AnyAccumulator) stream.collect(AnyAccumulator.supplier[Int], AnyAccumulator.unboxedIntAdder, AnyAccumulator.merger[Int]).asInstanceOf[C1]
       else if (info.companion == IntAccumulator) intAcc.asInstanceOf[C1]
       else if (stream.isParallel) intAcc.to(factory)
-      else factory.fromSpecific(stream.iterator.asInstanceOf[java.util.Iterator[Int]].asScala)
+      else factory.fromSpecific(stream.iterator.asInstanceOf[java.util.Iterator[Int]].asScala.nn)
     }
   }
 
@@ -330,7 +330,7 @@ trait StreamExtensions {
       if (info.companion == AnyAccumulator) stream.collect(AnyAccumulator.supplier[Long], AnyAccumulator.unboxedLongAdder, AnyAccumulator.merger[Long]).asInstanceOf[C1]
       else if (info.companion == LongAccumulator) longAcc.asInstanceOf[C1]
       else if (stream.isParallel) longAcc.to(factory)
-      else factory.fromSpecific(stream.iterator.asInstanceOf[java.util.Iterator[Long]].asScala)
+      else factory.fromSpecific(stream.iterator.asInstanceOf[java.util.Iterator[Long]].asScala.nn)
     }
   }
 
@@ -357,7 +357,7 @@ trait StreamExtensions {
       if (info.companion == AnyAccumulator) stream.collect(AnyAccumulator.supplier[Double], AnyAccumulator.unboxedDoubleAdder, AnyAccumulator.merger[Double]).asInstanceOf[C1]
       else if (info.companion == DoubleAccumulator) doubleAcc.asInstanceOf[C1]
       else if (stream.isParallel) doubleAcc.to(factory)
-      else factory.fromSpecific(stream.iterator.asInstanceOf[java.util.Iterator[Double]].asScala)
+      else factory.fromSpecific(stream.iterator.asInstanceOf[java.util.Iterator[Double]].asScala.nn)
     }
   }
 }

library/src/scala/collection/convert/impl/ArrayStepper.scala

@@ -16,7 +16,7 @@ package impl
 import scala.language.`2.13`
 import scala.collection._
 
-private[collection] class ObjectArrayStepper[A <: Object](underlying: Array[A], _i0: Int, _iN: Int)
+private[collection] class ObjectArrayStepper[A <: Object | Null](underlying: Array[A], _i0: Int, _iN: Int)
   extends IndexedStepperBase[AnyStepper[A], ObjectArrayStepper[A]](_i0, _iN)
     with AnyStepper[A] {
   def nextStep(): A = if (hasStep) { val j = i0; i0 += 1; underlying(j) } else Stepper.throwNSEE()