Address some comments

Author: noti0na1

compiler/src/dotty/tools/scripting/StringDriver.scala

@@ -31,7 +31,7 @@ class StringDriver(compilerArgs: Array[String], scalaSource: String) extends Dri
           try
             val classpath = s"${ctx.settings.classpath.value}${pathsep}${sys.props("java.class.path")}"
             val classpathEntries: Seq[Path] = ClassPath.expandPath(classpath, expandStar=true).map { Paths.get(_) }
-            sys.props("java.class.path") = classpathEntries.map(_.toString).mkString(pathsep.nn)
+            sys.props("java.class.path") = classpathEntries.map(_.toString).mkString(pathsep)
             detectMainClassAndMethod(outDir, classpathEntries, scalaSource) match
               case Right((mainClass, mainMethod)) =>
                 mainMethod.invoke(null, Array.empty[String])

compiler/src/dotty/tools/scripting/Util.scala

@@ -56,7 +56,7 @@ object Util:
     end match
   end detectMainClassAndMethod
 
-  def pathsep = sys.props("path.separator")
+  def pathsep: String = sys.props("path.separator").nn
 
 end Util
 

compiler/test/dotty/tools/io/ClasspathTest.scala

@@ -13,7 +13,7 @@ import dotty.tools.io.{ PlainDirectory, Directory, ClassPath }
 
 class ClasspathTest {
 
-  def pathsep = sys.props("path.separator")
+  def pathsep: String = sys.props("path.separator").nn
 
   def isWindows: Boolean = scala.util.Properties.isWin
 

library/src/scala/concurrent/BatchingExecutor.scala

@@ -100,7 +100,7 @@ private[concurrent] trait BatchingExecutor extends Executor {
   */
   private[this] sealed abstract class AbstractBatch protected (
     @annotation.stableNull protected final var first: Runnable | Null,
-    @annotation.stableNull protected final var other: Array[Runnable | Null],
+    protected final var other: Array[Runnable | Null],
     protected final var size: Int
   ) {
 
@@ -149,7 +149,7 @@ private[concurrent] trait BatchingExecutor extends Executor {
   }
 
   private[this] final class AsyncBatch private(_first: Runnable | Null, _other: Array[Runnable | Null], _size: Int) extends AbstractBatch(_first, _other, _size) with Runnable with BlockContext with (BlockContext => Throwable | Null) {
-    @annotation.stableNull private[this] final var parentBlockContext: BlockContext = BatchingExecutorStatics.MissingParentBlockContext
+    private[this] final var parentBlockContext: BlockContext = BatchingExecutorStatics.MissingParentBlockContext
 
     final def this(runnable: Runnable) = this(runnable, BatchingExecutorStatics.emptyBatchArray, 1)
 

library/src/scala/io/BufferedSource.scala

@@ -67,7 +67,7 @@ class BufferedSource(inputStream: InputStream, bufferSize: Int)(implicit val cod
 
   class BufferedLineIterator extends AbstractIterator[String] with Iterator[String] {
     private[this] val lineReader = decachedReader
-    var nextLine: String | Null = null
+    @annotation.stableNull var nextLine: String | Null = null
 
     override def hasNext = {
       if (nextLine == null)
@@ -78,10 +78,10 @@ class BufferedSource(inputStream: InputStream, bufferSize: Int)(implicit val cod
     override def next(): String = {
       val result = {
         if (nextLine == null) lineReader.readLine
-        else try nextLine.nn finally nextLine = null
+        else try nextLine finally nextLine = null
       }
       if (result == null) Iterator.empty.next()
-      else result.nn
+      else result
     }
   }
 

library/src/scala/jdk/FunctionExtensions.scala

@@ -34,7 +34,7 @@ extends mutable.AbstractMap[String, String | Null] {
   override def empty: mutable.Map[String, String | Null] = mutable.Map[String, String | Null]()
   override def default(key: String): String | Null = null
 
-  def iterator: Iterator[(String, String | Null)] = wrapAccess {
+  def iterator: Iterator[(String, String)] = wrapAccess {
     val ps = System.getProperties()
     names map (k => (k, ps getProperty k)) filter (_._2 ne null)
   } getOrElse Iterator.empty

library/src/scala/sys/SystemProperties.scala

@@ -234,10 +234,10 @@ object Sorting {
 
   // TODO: add upper bound: T <: AnyRef, propagate to callers below (not binary compatible)
   // Maybe also rename all these methods to `sort`.
-  @inline private def sort[T](a: Array[T] | Null, from: Int, until: Int, ord: Ordering[T]): Unit = (a: @unchecked) match {
-    case _: Array[AnyRef]  =>
+  @inline private def sort[T](a: Array[T], from: Int, until: Int, ord: Ordering[T]): Unit = (a: @unchecked) match {
+    case a: Array[AnyRef]  =>
       // Note that runtime matches are covariant, so could actually be any Array[T] s.t. T is not primitive (even boxed value classes)
-      if (a.nn.length > 1 && (ord eq null)) throw new NullPointerException("Ordering")
+      if (a.length > 1 && (ord eq null)) throw new NullPointerException("Ordering")
       java.util.Arrays.sort(a, from, until, ord)
     case a: Array[Int]     => if (ord eq Ordering.Int) java.util.Arrays.sort(a, from, until) else mergeSort[Int](a, from, until, ord)
     case a: Array[Double]  => mergeSort[Double](a, from, until, ord)  // Because not all NaNs are identical, stability is meaningful!