Add comments

noti0na1 · noti0na1 · commit e0e83d513267 · 2025-10-02T10:52:00.000+02:00
diff --git a/library-js/src/scala/runtime/ScalaRunTime.scala b/library-js/src/scala/runtime/ScalaRunTime.scala
@@ -252,10 +252,17 @@ object ScalaRunTime {
       case s => s + "\n"
     }
 
-  // For backwards compatibility with code compiled without -Yexplicit-nulls
+  // 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
 
+  // 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.
+  // We intentionally keep this signature to discourage passing nulls implicitly while
+  // preserving the previous behavior for backward compatibility.
+
   // Convert arrays to immutable.ArraySeq for use with Java varargs:
   def genericWrapArray[T](xs: Array[T]): ArraySeq[T] =
     mapNull(xs, ArraySeq.unsafeWrapArray(xs))
diff --git a/library/src/scala/IArray.scala b/library/src/scala/IArray.scala
@@ -336,25 +336,17 @@ object IArray:
   private inline def mapNull[A, B](a: A, inline f: B): B =
     if((a: A | Null) == null) null.asInstanceOf[B] else f
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
+  // 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.
+  // We intentionally keep this signature to discourage passing nulls implicitly while
+  // preserving the previous behavior for backward compatibility.
+
+  /** Conversion from IArray to immutable.ArraySeq */
   implicit def genericWrapArray[T](arr: IArray[T]): ArraySeq[T] =
     mapNull(arr, ArraySeq.unsafeWrapArray(arr))
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
-  // TODO!!! only for stdliib migration!
-  import scala.language.unsafeNulls
+  /** Conversion from IArray to immutable.ArraySeq */
+  import scala.language.unsafeNulls // TODO!!! only for stdliib 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
@@ -365,93 +357,39 @@ object IArray:
       else ArraySeq.ofRef[AnyRef](arr.asInstanceOf[Array[AnyRef]]).asInstanceOf[ArraySeq.ofRef[T]]
     )
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
+  /** Conversion from IArray to immutable.ArraySeq */
   implicit def wrapIntArray(arr: IArray[Int]): ArraySeq.ofInt =
     mapNull(arr, new ArraySeq.ofInt(arr.asInstanceOf[Array[Int]]))
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
+  /** Conversion from IArray to immutable.ArraySeq */
   implicit def wrapDoubleIArray(arr: IArray[Double]): ArraySeq.ofDouble =
     mapNull(arr, new ArraySeq.ofDouble(arr.asInstanceOf[Array[Double]]))
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
+  /** Conversion from IArray to immutable.ArraySeq */
   implicit def wrapLongIArray(arr: IArray[Long]): ArraySeq.ofLong =
     mapNull(arr, new ArraySeq.ofLong(arr.asInstanceOf[Array[Long]]))
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
+  /** Conversion from IArray to immutable.ArraySeq */
   implicit def wrapFloatIArray(arr: IArray[Float]): ArraySeq.ofFloat =
     mapNull(arr, new ArraySeq.ofFloat(arr.asInstanceOf[Array[Float]]))
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
+  /** Conversion from IArray to immutable.ArraySeq */
   implicit def wrapCharIArray(arr: IArray[Char]): ArraySeq.ofChar =
     mapNull(arr, new ArraySeq.ofChar(arr.asInstanceOf[Array[Char]]))
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
+  /** Conversion from IArray to immutable.ArraySeq */
   implicit def wrapByteIArray(arr: IArray[Byte]): ArraySeq.ofByte =
     mapNull(arr, new ArraySeq.ofByte(arr.asInstanceOf[Array[Byte]]))
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
+  /** Conversion from IArray to immutable.ArraySeq */
   implicit def wrapShortIArray(arr: IArray[Short]): ArraySeq.ofShort =
     mapNull(arr, new ArraySeq.ofShort(arr.asInstanceOf[Array[Short]]))
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
+  /** Conversion from IArray to immutable.ArraySeq */
   implicit def wrapBooleanIArray(arr: IArray[Boolean]): ArraySeq.ofBoolean =
     mapNull(arr, new ArraySeq.ofBoolean(arr.asInstanceOf[Array[Boolean]]))
 
-  /** Conversion from IArray to immutable.ArraySeq.
-   *
-   *  Note: Both the parameter and the return type are non-nullable. However, if a null
-   *  reference is passed explicitly, this method will still return null. We intentionally
-   *  keep this signature to discourage passing nulls implicitly while preserving the
-   *  previous behavior for backward compatibility.
-   */
+  /** Conversion from IArray to immutable.ArraySeq */
   implicit def wrapUnitIArray(arr: IArray[Unit]): ArraySeq.ofUnit =
     mapNull(arr, new ArraySeq.ofUnit(arr.asInstanceOf[Array[Unit]]))
 
diff --git a/library/src/scala/StringContext.scala b/library/src/scala/StringContext.scala
@@ -95,7 +95,7 @@ case class StringContext(parts: String*) {
   object s {
     /** The simple string matcher.
      *
-     *  Attempts to match the input string to the given interpolated patterns via
+     *  Attempts to match the input string to the given interpolated patterns via 
      *  a naive globbing, that is the reverse of the simple interpolator.
      *
      *  Here is an example usage:
@@ -206,7 +206,7 @@ object StringContext {
     *                      separated by wildcards
     * @param input The input you wish to match against
     * @return None if there is no match, Some containing the sequence of matched
-    *         wildcard strings if there is a match
+    *         wildcard strings if there is a match 
     */
   def glob(patternChunks: Seq[String], input: String): Option[Seq[String]] = {
     var patternIndex = 0
@@ -317,7 +317,7 @@ object StringContext {
     val len = src.length()
     def loop(uindex: Int): (Char, Int) = {
       def loopCP(dindex: Int, codepoint: Int): (Char, Int) = {
-        //supports BMP + surrogate escapes
+        //supports BMP + surrogate escapes 
         //but only in four hex-digit code units (uxxxx)
         if(dindex >= 4) {
           val usRead = uindex - startindex
@@ -475,4 +475,3 @@ object StringContext {
         +") for interpolated string with "+ parts.length +" parts")
 
 }
-
diff --git a/library/src/scala/collection/JavaConverters.scala b/library/src/scala/collection/JavaConverters.scala
@@ -110,6 +110,7 @@ object JavaConverters extends AsJavaConverters with AsScalaConverters {
   @deprecated("Use `asJava` instead", "2.13.0")
   def mapAsJavaConcurrentMap[K, V](m: concurrent.Map[K, V]): juc.ConcurrentMap[K, V] = asJava(m)
 
+
   @deprecated("Use `asScala` instead", "2.13.0")
   def asScalaIterator[A](i: ju.Iterator[A]): Iterator[A] = asScala(i)
 
diff --git a/library/src/scala/collection/convert/AsJavaConverters.scala b/library/src/scala/collection/convert/AsJavaConverters.scala
@@ -24,6 +24,11 @@ import scala.{unchecked => uc}
 
 /** Defines converter methods from Scala to Java collections.
   * These methods are available through the [[scala.jdk.javaapi.CollectionConverters]] object.
+  *
+  * Note: Both the parameter and the return type are non-nullable. However, if a null
+  * reference is passed explicitly, this method will still return null. We intentionally
+  * keep this signature to discourage passing nulls implicitly while preserving the
+  * previous behavior for backward compatibility.
   */
 trait AsJavaConverters {
   import JavaCollectionWrappers._
diff --git a/library/src/scala/collection/convert/AsScalaConverters.scala b/library/src/scala/collection/convert/AsScalaConverters.scala
@@ -25,6 +25,11 @@ import scala.{unchecked => uc}
 
 /** Defines converter methods from Java to Scala collections.
   * These methods are available through the [[scala.jdk.javaapi.CollectionConverters]] object.
+  *
+  * Note: Both the parameter and the return type are non-nullable. However, if a null
+  * reference is passed explicitly, this method will still return null. We intentionally
+  * keep this signature to discourage passing nulls implicitly while preserving the
+  * previous behavior for backward compatibility.
   */
 trait AsScalaConverters {
   import JavaCollectionWrappers._
