Add missing @param/@tparam/@return Scaladoc tags in loose root files (Array, IArray, Option, Predef, Function, Tuple, MatchError, and numeric types) (cleanup follow-up)

Author: bvenners

library-js/src/scala/Array.scala

@@ -65,6 +65,7 @@ object Array {
    *
    *  @tparam A the element type of the array, must have a `ClassTag`
    *  @param dummy the `Array` companion object, used to trigger the implicit conversion
+   *  @return a `Factory` that builds an `Array[A]` from an `IterableOnce[A]`
    */
   implicit def toFactory[A : ClassTag](dummy: Array.type): Factory[A, Array[A]] = new ArrayFactory(dummy)
   @SerialVersionUID(3L)
@@ -77,6 +78,7 @@ object Array {
    *
    *  @tparam T the element type of the array to build
    *  @param t the `ClassTag` for the element type, used to create the correct array type at runtime
+   *  @return a new `ArrayBuilder[T]` for incrementally constructing an `Array[T]`
    */
   def newBuilder[T](implicit t: ClassTag[T]): ArrayBuilder[T] = ArrayBuilder.make[T](using t)
 
@@ -212,6 +214,7 @@ object Array {
   /** Returns an array of length 0.
    *
    *  @tparam T the element type of the empty array
+   *  @return an empty `Array[T]` of length `0`
    */
   def empty[T: ClassTag]: Array[T] = new Array[T](0)
 
@@ -236,6 +239,7 @@ object Array {
    *
    *  @param x the first element
    *  @param xs the remaining elements
+   *  @return an `Array[Boolean]` containing `x` followed by all elements of `xs`
    */
   // Subject to a compiler optimization in Cleanup, see above.
   def apply(x: Boolean, xs: Boolean*): Array[Boolean] = {
@@ -253,6 +257,7 @@ object Array {
    *
    *  @param x the first element
    *  @param xs the remaining elements
+   *  @return an `Array[Byte]` containing `x` followed by all elements of `xs`
    */
   // Subject to a compiler optimization in Cleanup, see above.
   def apply(x: Byte, xs: Byte*): Array[Byte] = {
@@ -270,6 +275,7 @@ object Array {
    *
    *  @param x the first element
    *  @param xs the remaining elements
+   *  @return an `Array[Short]` containing `x` followed by all elements of `xs`
    */
   // Subject to a compiler optimization in Cleanup, see above.
   def apply(x: Short, xs: Short*): Array[Short] = {
@@ -287,6 +293,7 @@ object Array {
    *
    *  @param x the first element
    *  @param xs the remaining elements
+   *  @return an `Array[Char]` containing `x` followed by all elements of `xs`
    */
   // Subject to a compiler optimization in Cleanup, see above.
   def apply(x: Char, xs: Char*): Array[Char] = {
@@ -304,6 +311,7 @@ object Array {
    *
    *  @param x the first element
    *  @param xs the remaining elements
+   *  @return an `Array[Int]` containing `x` followed by all elements of `xs`
    */
   // Subject to a compiler optimization in Cleanup, see above.
   def apply(x: Int, xs: Int*): Array[Int] = {
@@ -321,6 +329,7 @@ object Array {
    *
    *  @param x the first element
    *  @param xs the remaining elements
+   *  @return an `Array[Long]` containing `x` followed by all elements of `xs`
    */
   // Subject to a compiler optimization in Cleanup, see above.
   def apply(x: Long, xs: Long*): Array[Long] = {
@@ -338,6 +347,7 @@ object Array {
    *
    *  @param x the first element
    *  @param xs the remaining elements
+   *  @return an `Array[Float]` containing `x` followed by all elements of `xs`
    */
   // Subject to a compiler optimization in Cleanup, see above.
   def apply(x: Float, xs: Float*): Array[Float] = {
@@ -355,6 +365,7 @@ object Array {
    *
    *  @param x the first element
    *  @param xs the remaining elements
+   *  @return an `Array[Double]` containing `x` followed by all elements of `xs`
    */
   // Subject to a compiler optimization in Cleanup, see above.
   def apply(x: Double, xs: Double*): Array[Double] = {
@@ -372,6 +383,7 @@ object Array {
    *
    *  @param x the first element
    *  @param xs the remaining elements
+   *  @return an `Array[Unit]` containing `x` followed by all elements of `xs`
    */
   def apply(x: Unit, xs: Unit*): Array[Unit] = {
     val array = new Array[Unit](xs.length + 1)
@@ -388,6 +400,7 @@ object Array {
    *
    *  @tparam T the element type of the array
    *  @param n1 the number of elements in the 1st dimension
+   *  @return a new `Array[T]` of length `n1` with all elements initialized to their default value
    */
   def ofDim[T: ClassTag](n1: Int): Array[T] =
     new Array[T](n1)
@@ -396,6 +409,7 @@ object Array {
    *  @tparam T the element type of the array
    *  @param n1 the number of elements in the 1st dimension
    *  @param n2 the number of elements in the 2nd dimension
+   *  @return a new `Array[Array[T]]` with dimensions `n1 x n2`, with all elements initialized to their default value
    */
   def ofDim[T: ClassTag](n1: Int, n2: Int): Array[Array[T]] = {
     val arr: Array[Array[T]] = (new Array[Array[T]](n1): Array[Array[T]])
@@ -409,6 +423,7 @@ object Array {
    *  @param n1 the number of elements in the 1st dimension
    *  @param n2 the number of elements in the 2nd dimension
    *  @param n3 the number of elements in the 3rd dimension
+   *  @return a new `Array[Array[Array[T]]]` of size `n1 x n2 x n3`, with all elements initialized to their default value
    */
   def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int): Array[Array[Array[T]]] =
     tabulate(n1)(_ => ofDim[T](n2, n3))
@@ -419,6 +434,7 @@ object Array {
    *  @param n2 the number of elements in the 2nd dimension
    *  @param n3 the number of elements in the 3rd dimension
    *  @param n4 the number of elements in the 4th dimension
+   *  @return a new `Array[Array[Array[Array[T]]]]` of size `n1 x n2 x n3 x n4`, with all elements initialized to their default value
    */
   def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int): Array[Array[Array[Array[T]]]] =
     tabulate(n1)(_ => ofDim[T](n2, n3, n4))
@@ -430,6 +446,7 @@ object Array {
    *  @param n3 the number of elements in the 3rd dimension
    *  @param n4 the number of elements in the 4th dimension
    *  @param n5 the number of elements in the 5th dimension
+   *  @return a new `Array[Array[Array[Array[Array[T]]]]]` of size `n1 x n2 x n3 x n4 x n5`, with all elements initialized to their default value
    */
   def ofDim[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int): Array[Array[Array[Array[Array[T]]]]] =
     tabulate(n1)(_ => ofDim[T](n2, n3, n4, n5))
@@ -483,6 +500,7 @@ object Array {
    *  @param   n1  the number of elements in the 1st dimension
    *  @param   n2  the number of elements in the 2nd dimension
    *  @param   elem the element computation
+   *  @return a 2-dimensional `Array[Array[T]]` of size `n1 x n2`, where each element contains the result of (separately) computing `elem`
    */
   def fill[T: ClassTag](n1: Int, n2: Int)(elem: => T): Array[Array[T]] =
     tabulate(n1)(_ => fill(n2)(elem))
@@ -495,6 +513,7 @@ object Array {
    *  @param   n2  the number of elements in the 2nd dimension
    *  @param   n3  the number of elements in the 3rd dimension
    *  @param   elem the element computation
+   *  @return a 3-dimensional array of size `n1 x n2 x n3`, where each element contains the result of (separately) computing `elem`
    */
   def fill[T: ClassTag](n1: Int, n2: Int, n3: Int)(elem: => T): Array[Array[Array[T]]] =
     tabulate(n1)(_ => fill(n2, n3)(elem))
@@ -508,6 +527,7 @@ object Array {
    *  @param   n3  the number of elements in the 3rd dimension
    *  @param   n4  the number of elements in the 4th dimension
    *  @param   elem the element computation
+   *  @return a 4-dimensional array of size `n1 x n2 x n3 x n4`, where each element contains the result of (separately) computing `elem`
    */
   def fill[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => T): Array[Array[Array[Array[T]]]] =
     tabulate(n1)(_ => fill(n2, n3, n4)(elem))
@@ -522,6 +542,7 @@ object Array {
    *  @param   n4  the number of elements in the 4th dimension
    *  @param   n5  the number of elements in the 5th dimension
    *  @param   elem the element computation
+   *  @return a 5-dimensional array of size `n1 x n2 x n3 x n4 x n5`, where each element contains the result of (separately) computing `elem`
    */
   def fill[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => T): Array[Array[Array[Array[Array[T]]]]] =
     tabulate(n1)(_ => fill(n2, n3, n4, n5)(elem))
@@ -555,6 +576,7 @@ object Array {
    *  @param   n1  the number of elements in the 1st dimension
    *  @param   n2  the number of elements in the 2nd dimension
    *  @param   f   The function computing element values
+   *  @return a 2-dimensional `Array[Array[T]]` of size `n1 x n2`, where element `(i1, i2)` is `f(i1, i2)`
    */
   def tabulate[T: ClassTag](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]] =
     tabulate(n1)(i1 => tabulate(n2)(f(i1, _)))
@@ -567,6 +589,7 @@ object Array {
    *  @param   n2  the number of elements in the 2nd dimension
    *  @param   n3  the number of elements in the 3rd dimension
    *  @param   f   The function computing element values
+   *  @return a 3-dimensional array of size `n1 x n2 x n3`, where element `(i1, i2, i3)` is `f(i1, i2, i3)`
    */
   def tabulate[T: ClassTag](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => T): Array[Array[Array[T]]] =
     tabulate(n1)(i1 => tabulate(n2, n3)(f(i1, _, _)))
@@ -580,6 +603,7 @@ object Array {
    *  @param   n3  the number of elements in the 3rd dimension
    *  @param   n4  the number of elements in the 4th dimension
    *  @param   f   The function computing element values
+   *  @return a 4-dimensional array of size `n1 x n2 x n3 x n4`, where element `(i1, i2, i3, i4)` is `f(i1, i2, i3, i4)`
    */
   def tabulate[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => T): Array[Array[Array[Array[T]]]] =
     tabulate(n1)(i1 => tabulate(n2, n3, n4)(f(i1, _, _, _)))
@@ -594,6 +618,7 @@ object Array {
    *  @param   n4  the number of elements in the 4th dimension
    *  @param   n5  the number of elements in the 5th dimension
    *  @param   f   The function computing element values
+   *  @return a 5-dimensional array of size `n1 x n2 x n3 x n4 x n5`, where element `(i1, i2, i3, i4, i5)` is `f(i1, i2, i3, i4, i5)`
    */
   def tabulate[T: ClassTag](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => T): Array[Array[Array[Array[Array[T]]]]] =
     tabulate(n1)(i1 => tabulate(n2, n3, n4, n5)(f(i1, _, _, _, _)))
@@ -760,6 +785,7 @@ object Array {
  *  @define undefinedorder
  *
  *  @tparam T the type of the elements in the array
+ *  @param _length the length of the array
  */
 final class Array[T](_length: Int) extends java.io.Serializable with java.lang.Cloneable { self =>
 

library-js/src/scala/MatchError.scala

@@ -15,6 +15,8 @@ package scala
 /** This class implements errors which are thrown whenever an
  *  object doesn't match any pattern of a pattern matching
  *  expression.
+ *
+ *  @param obj the object that failed to match any pattern
  */
 final class MatchError(@transient obj: Any) extends RuntimeException {
   /** There's no reason we need to call toString eagerly,