Drop all non-user-facing Scaladoc

17 of the documented declarations on this branch are private,
private[x], protected[x], or nested inside such a scope. scaladoc's
isHiddenByVisibility drops every one of them unless -private is passed,
and no build in this repository passes it, so none of this reaches the
published API pages. This commit removes them, 113 comment line(s)
across 3 file(s), leaving only documentation the API pages render.

Nothing is lost: scaladoc-missing-docs-runtime-internal restores this tree exactly.

Author: bvenners

library/src/scala/runtime/ClassValueCompat.scala

@@ -21,78 +21,26 @@ private[scala] abstract class ClassValueCompat[T] extends ClassValueInterface[T]
     else new FallbackClassValue()
 
   private class JavaClassValue extends ClassValue[T] with ClassValueInterface[T] {
-    /** Computes the value for `cls` by delegating to the enclosing
-     *  `ClassValueCompat`'s `computeValue`; `java.lang.ClassValue` caches
-     *  the result per class.
-     *
-     *  @param cls the class to compute the value for
-     *  @return the computed value
-     */
     override def computeValue(cls: Class[?]): T = self.computeValue(cls)
   }
 
   private class FallbackClassValue extends ClassValueInterface[T] {
-    /** Returns the value for `cls`, computed by the enclosing
-     *  `ClassValueCompat`'s `computeValue` on every call: the fallback
-     *  caches nothing.
-     *
-     *  @param cls the class to compute the value for
-     */
     override def get(cls: Class[?]): T = self.computeValue(cls)
 
-    /** Does nothing: the fallback caches no values, so there is nothing to
-     *  remove.
-     *
-     *  @param cls never used
-     */
     override def remove(cls: Class[?]): Unit = {}
   }
 
-  /** Returns the value associated with `cls`: when `java.lang.ClassValue`
-   *  is available, from its per-class cache, computed by `computeValue` on
-   *  first access; otherwise by calling `computeValue` on every call.
-   *
-   *  @param cls the class to get the value for
-   */
   def get(cls: Class[?]): T = instance.get(cls)
 
-  /** Removes the cached value for `cls`, so that the next `get` recomputes
-   *  it; does nothing when `java.lang.ClassValue` is unavailable, since
-   *  nothing is cached then.
-   *
-   *  @param cls the class whose cached value to remove
-   */
   def remove(cls: Class[?]): Unit = instance.remove(cls)
 
-  /** Computes the value to associate with `cls`.
-   *
-   *  Called by `get`: when backed by `java.lang.ClassValue`, on the first
-   *  access for each class (and again after `remove`); otherwise on every
-   *  call.
-   *
-   *  @param cls the class to compute the value for
-   *  @return the value to associate with `cls`
-   */
   protected def computeValue(cls: Class[?]): T
 }
 
 private[scala] object ClassValueCompat {
-  /** A common interface over `java.lang.ClassValue` and the non-caching
-   *  fallback used on runtimes where that class cannot be loaded.
-   *
-   *  @tparam T the type of the value derived from a class
-   */
   trait ClassValueInterface[T] {
-    /** Returns the value for `cls`, computing it if necessary.
-     *
-     *  @param cls the class to get the value for
-     */
     def get(cls: Class[?]): T
 
-    /** Removes any cached value for `cls`.
-     *
-     *  @param cls the class whose cached value to remove
-     */
     def remove(cls: Class[?]): Unit
   }
 

library/src/scala/runtime/MethodCache.scala

@@ -38,35 +38,13 @@ private[scala] sealed abstract class MethodCache {
    *  @return the cached `JMethod` compatible with `forReceiver`, or `null` if no such method is cached (in which case the caller should look up the method and `add` it)
    */
   def find(forReceiver: JClass[?]): JMethod | Null
-  /** Returns a cache that also resolves `forMethod` for receiver class
-   *  `forReceiver`, to replace this cache at the call point. This cache
-   *  itself is not mutated: implementations return either a new cache
-   *  extending this one or this cache unchanged.
-   *
-   *  @param forReceiver the runtime `Class` of the receiver object the method was looked up for
-   *  @param forMethod the method resolved for `forReceiver`
-   *  @return the cache to use for subsequent look-ups at this call point
-   */
   def add(forReceiver: JClass[?], forMethod: JMethod): MethodCache
 }
 
 private[scala] final class EmptyMethodCache extends MethodCache {
 
-  /** Returns `null`: the empty cache contains no methods, so the caller
-   *  should look up the method and `add` it.
-   *
-   *  @param forReceiver the runtime `Class` of the receiver object; never used
-   */
   def find(forReceiver: JClass[?]): JMethod | Null = null
 
-  /** Returns a new single-entry [[PolyMethodCache]] of complexity 1 that
-   *  resolves `forMethod` for receiver class `forReceiver`, with this empty
-   *  cache as the end of its chain.
-   *
-   *  @param forReceiver the runtime `Class` of the receiver object the method was looked up for
-   *  @param forMethod the method resolved for `forReceiver`
-   *  @return the new one-entry cache
-   */
   def add(forReceiver: JClass[?], forMethod: JMethod): MethodCache =
     new PolyMethodCache(this, forReceiver, forMethod, 1)
 
@@ -77,24 +55,9 @@ private[scala] final class MegaMethodCache(
   private val forParameterTypes: Array[JClass[?]]
 ) extends MethodCache {
 
-  /** Returns the public method of `forReceiver` with this cache's method
-   *  name and parameter types, resolved reflectively via `getMethod` on
-   *  every call: a mega-morphic cache stores no per-receiver entries.
-   *
-   *  @param forReceiver the runtime `Class` of the receiver object to resolve the method on
-   *  @return the resolved method; never `null`
-   *  @throws NoSuchMethodException if `forReceiver` has no public method
-   *          with this cache's name and parameter types
-   */
   def find(forReceiver: JClass[?]): JMethod | Null =
     forReceiver.getMethod(forName, forParameterTypes*)
 
-  /** Returns this cache unchanged: a mega-morphic cache resolves methods
-   *  reflectively in `find` and records no per-receiver entries.
-   *
-   *  @param forReceiver never used
-   *  @param forMethod never used
-   */
   def add(forReceiver: JClass[?], forMethod: JMethod): MethodCache = this
 
 }
@@ -119,27 +82,11 @@ private[scala] final class PolyMethodCache(
       case _                  => next find forReceiver
     }
 
-  /** Returns the cached method whose receiver class is reference-equal to
-   *  `forReceiver` anywhere in this chain, or `null` if no entry matches
-   *  (in which case the caller should look up the method and `add` it).
-   *
-   *  @param forReceiver the runtime `Class` of the receiver object to look up in the cache chain
-   */
   def find(forReceiver: JClass[?]): JMethod | Null = findInternal(forReceiver)
 
   // TODO: come up with a more realistic number
   final private val MaxComplexity = 160
 
-  /** Returns a new [[PolyMethodCache]] that prepends the entry
-   *  (`forReceiver`, `forMethod`) to this chain, unless this chain has
-   *  reached `MaxComplexity` entries, in which case the call point has
-   *  turned mega-morphic: returns a [[MegaMethodCache]] for the method's
-   *  name and parameter types, discarding the per-receiver entries.
-   *
-   *  @param forReceiver the runtime `Class` of the receiver object the method was looked up for
-   *  @param forMethod the method resolved for `forReceiver`
-   *  @return the extended chain, or a mega-morphic cache at the cutover
-   */
   def add(forReceiver: JClass[?], forMethod: JMethod): MethodCache =
     if (complexity < MaxComplexity)
       new PolyMethodCache(this, forReceiver, forMethod, complexity + 1)

library/src/scala/runtime/PStatics.scala

@@ -19,13 +19,5 @@ import scala.language.`2.13`
 private[scala] object PStatics {
   // `Int.MaxValue - 8` traditional soft limit to maximize compatibility with diverse JVMs
   // See https://stackoverflow.com/a/8381338 for example
-  /** The largest array length that common JVMs reliably allow:
-   *  `Int.MaxValue - 8`.
-   *
-   *  Although array lengths are `Int`s, some VMs reserve a few header words
-   *  in an array, so requesting a length above this limit can throw
-   *  `OutOfMemoryError` even when enough memory is available. Array-backed
-   *  collections use this value as the cap when growing their backing arrays.
-   */
   final val VM_MaxArraySize = 2147483639
 }