Address comments

Author: noti0na1

library/src/scala/IArray.scala

@@ -346,12 +346,11 @@ object IArray:
     mapNull(arr, ArraySeq.unsafeWrapArray(arr))
 
   /** Conversion from IArray to immutable.ArraySeq */
-  import scala.language.unsafeNulls // TODO!!! only for stdliib migration!
+  import scala.language.unsafeNulls // TODO!!! only for stdlib migration!
   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.
-    // import scala.language.unsafeNulls
     mapNull(arr,
       if (arr.length == 0) ArraySeq.empty[AnyRef | Null].asInstanceOf[ArraySeq.ofRef[T]]
       else ArraySeq.ofRef[AnyRef](arr.asInstanceOf[Array[AnyRef]]).asInstanceOf[ArraySeq.ofRef[T]]

library/src/scala/Predef.scala

@@ -594,6 +594,7 @@ object Predef extends LowPriorityImplicits {
       !(x eq y)
 
   extension (opt: Option.type)
+    @experimental
     inline def fromNullable[T](t: T | Null): Option[T] = Option(t).asInstanceOf[Option[T]]
 
   // For backward compatibility with code compiled without -Yexplicit-nulls.

library/src/scala/collection/mutable/AnyRefMap.scala

@@ -202,7 +202,7 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K -> V, initi
    */
   def getOrNull(key: K): V | Null = {
     val i = seekEntry(hashOf(key), key)
-    if (i < 0) null else _values(i).asInstanceOf[V | Null]
+    if (i < 0) null else _values(i).asInstanceOf[V]
   }
 
   /** Retrieves the value associated with a key.

library/src/scala/collection/mutable/ListBuffer.scala

@@ -321,7 +321,7 @@ class ListBuffer[A]
    *  @param f the mapping function
    *  @return this $coll
    */
-  def flatMapInPlace(f: A => IterableOnce[A]): this.type = {
+  def flatMapInPlace(f: A => IterableOnce[A]^): this.type = {
     mutationCount += 1
     var src = first
     var dst: List[A] | Null = null

library/src/scala/collection/mutable/LongMap.scala

@@ -470,6 +470,7 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff
 
   @deprecated("Use ++ with an explicit collection argument instead of + with varargs", "2.13.0")
   override def + [V1 >: V](elem1: (Long, V1), elem2: (Long, V1), elems: (Long, V1)*): LongMap[V1]^{} = {
+    // TODO: An empty capture annotation is needed in the result type to satisfy the overriding checker.
     val m = this + elem1 + elem2
     if(elems.isEmpty) m else m.concat(elems)
   }

library/src/scala/collection/mutable/RedBlackTree.scala

@@ -146,7 +146,8 @@ private[collection] object RedBlackTree {
   private[this] def minNodeAfter[A, B](node: Node[A, B] | Null, key: A)(implicit ord: Ordering[A]): Node[A, B] | Null = {
     if (node eq null) null
     else {
-      var y: Node[A, B] | Null = null
+      // We know x is not null initially, so y will only be null before the first iteration of the loop.
+      var y: Node[A, B] = null.asInstanceOf[Node[A, B]]
       var x: Node[A, B] | Null = node
       var cmp = 1
       while ((x ne null) && cmp != 0) {
@@ -176,7 +177,8 @@ private[collection] object RedBlackTree {
   private[this] def maxNodeBefore[A, B](node: Node[A, B] | Null, key: A)(implicit ord: Ordering[A]): Node[A, B] | Null = {
     if (node eq null) null
     else {
-      var y: Node[A, B] | Null = null
+      // We know x is not null initially, so y will only be null before the first iteration of the loop.
+      var y: Node[A, B] = null.asInstanceOf[Node[A, B]]
       var x: Node[A, B] | Null = node
       var cmp = 1
       while ((x ne null) && cmp != 0) {
@@ -364,9 +366,8 @@ private[collection] object RedBlackTree {
    * Returns the node that follows `node` in an in-order tree traversal. If `node` has the maximum key (and is,
    * therefore, the last node), this method returns `null`.
    */
-  private[this] def successor[A, B](node: Node[A, B] | Null): Node[A, B] | Null = {
-    if (node eq null) null
-    else if (node.right ne null) minNodeNonNull(node.right)
+  private[this] def successor[A, B](node: Node[A, B]): Node[A, B] | Null = {
+    if (node.right ne null) minNodeNonNull(node.right)
     else {
       var x = node
       var y = x.parent
@@ -382,9 +383,8 @@ private[collection] object RedBlackTree {
    * Returns the node that precedes `node` in an in-order tree traversal. If `node` has the minimum key (and is,
    * therefore, the first node), this method returns `null`.
    */
-  private[this] def predecessor[A, B](node: Node[A, B] | Null): Node[A, B] | Null = {
-    if (node eq null) null
-    else if (node.left ne null) maxNodeNonNull(node.left)
+  private[this] def predecessor[A, B](node: Node[A, B]): Node[A, B] | Null = {
+    if (node.left ne null) maxNodeNonNull(node.left)
     else {
       var x = node
       var y = x.parent

library/src/scala/runtime/stdLibPatches/Predef.scala

@@ -67,6 +67,7 @@ object Predef:
       !(x eq y)
 
   extension (opt: Option.type)
+    @experimental
     inline def fromNullable[T](t: T | Null): Option[T] = Option(t).asInstanceOf[Option[T]]
 
   /** A type supporting Self-based type classes.