Address some review comments

Author: noti0na1

library/src/scala/collection/immutable/RedBlackTree.scala

@@ -424,7 +424,7 @@ private[collection] object RedBlackTree {
   }
 
   private[this] def upd[A, B, B1 >: B](tree: Tree[A, B] | Null, k: A, v: B1, overwrite: Boolean)(implicit ordering: Ordering[A]): Tree[A, B1] = if (tree eq null) {
-    RedTree(k, v, null: Tree[A, B1] | Null, null: Tree[A, B1] | Null)
+    RedTree[A, B1](k, v, null, null)
   } else if (k.asInstanceOf[AnyRef] eq tree.key.asInstanceOf[AnyRef]) {
     if (overwrite)
       tree.withV(v)

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]
+    if (i < 0) null else _values(i).asInstanceOf[V | Null]
   }
 
   /** Retrieves the value associated with a key.

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

@@ -189,7 +189,7 @@ class ListBuffer[A]
       last0 = null
   }
 
-  private def locate(i: Int): Predecessor[A] | Null =
+  private def locate(i: Int): Predecessor[A] =
     if (i == 0) null
     else if (i == len) last0
     else {
@@ -202,7 +202,7 @@ class ListBuffer[A]
       p.asInstanceOf[Predecessor[A]]
     }
 
-  private def getNext(p: Predecessor[A] | Null): List[A] =
+  private def getNext(p: Predecessor[A]): List[A] =
     if (p == null) first else p.next
 
   def update(idx: Int, elem: A): Unit = {
@@ -243,7 +243,7 @@ class ListBuffer[A]
   }
 
   // `fresh` must be a `ListBuffer` that only we have access to
-  private def insertAfter(prev: Predecessor[A] | Null, fresh: ListBuffer[A]): Unit = {
+  private def insertAfter(prev: Predecessor[A], fresh: ListBuffer[A]): Unit = {
     if (!fresh.isEmpty) {
       val follow = getNext(prev)
       if (prev eq null) first = fresh.first else prev.next = fresh.first
@@ -291,7 +291,7 @@ class ListBuffer[A]
       throw new IllegalArgumentException("removing negative number of elements: " + count)
     }
 
-  private def removeAfter(prev: Predecessor[A] | Null, n: Int) = {
+  private def removeAfter(prev: Predecessor[A], n: Int) = {
     @tailrec def ahead(p: List[A], n: Int): List[A] =
       if (n == 0) p else ahead(p.tail, n - 1)
     val nx = ahead(getNext(prev), n)
@@ -348,7 +348,7 @@ class ListBuffer[A]
    */
   def filterInPlace(p: A => Boolean): this.type = {
     ensureUnaliased()
-    var prev: Predecessor[A] | Null = null
+    var prev: Predecessor[A] = null
     var cur: List[A] = first
     while (!cur.isEmpty) {
       val follow = cur.tail

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

@@ -230,7 +230,7 @@ final class LongMap[V] private[collection] (defaultEntry: Long -> V, initialBuff
     }
     else {
       val i = seekEntry(key)
-      if (i < 0) null else _values(i).asInstanceOf[V]
+      if (i < 0) null else _values(i).asInstanceOf[V | Null]
     }
   }
 

library/src/scala/util/Properties.scala

@@ -54,10 +54,10 @@ private[scala] trait PropertiesTrait {
 
   def propIsSet(name: String)                   = System.getProperty(name) != null
   def propIsSetTo(name: String, value: String)  = propOrNull(name) == value
-  def propOrElse(name: String, alt: => String | Null)  = Option(System.getProperty(name)).getOrElse(alt)
+  def propOrNone(name: String): Option[String]  = Option[String](System.getProperty(name))
+  def propOrElse(name: String, alt: => String)  = propOrNone(name).getOrElse(alt)
   def propOrEmpty(name: String)                 = propOrElse(name, "")
-  def propOrNull(name: String): String | Null   = propOrElse(name, null)
-  def propOrNone(name: String)                  = Option(propOrNull(name))
+  def propOrNull(name: String): String | Null   = propOrNone(name).orNull
   def propOrFalse(name: String)                 = propOrNone(name) exists (x => List("yes", "on", "true") contains x.nn.toLowerCase)
   def setProp(name: String, value: String)      = System.setProperty(name, value)
   def clearProp(name: String)                   = System.clearProperty(name)

library/src/scala/util/Using.scala

@@ -177,8 +177,7 @@ object Using {
     import Manager._
 
     private var closed = false
-    @annotation.stableNull
-    private[this] var resources: List[Resource[_]] | Null = Nil
+    private[this] var resources: List[Resource[_]] = Nil
 
     /** Registers the specified resource with this manager, so that
       * the resource is released when the manager is closed, and then
@@ -195,7 +194,7 @@ object Using {
     def acquire[R: Releasable](resource: R): Unit = {
       if (resource == null) throw new NullPointerException("null resource")
       if (closed) throw new IllegalStateException("Manager has already been closed")
-      resources = new Resource(resource) :: resources.nn
+      resources = new Resource(resource) :: resources
     }
 
     private def manage[A](op: Manager => A): A = {
@@ -209,7 +208,7 @@ object Using {
       } finally {
         closed = true
         var rs = resources
-        resources = null // allow GC, in case something is holding a reference to `this`
+        resources = null.asInstanceOf[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