[NFC] Update invalid references in stdlib KDoc

Merge-request: KT-MR-22767
Merged-by: Filipp Zhinkin <[email protected]>

Author: fzhinkin

kotlin-native/runtime/src/main/kotlin/kotlin/native/BitSet.kt

@@ -232,7 +232,7 @@ actual constructor(size: Int = ELEMENT_SIZE) {
      * (if [lookFor] == false) bit after [startIndex] (inclusive).
      * Returns -1 (for [lookFor] == true) or [size] (for lookFor == false)
      * if there is no such bits between [startIndex] and [size] - 1.
-     * @throws IndexOutOfBoundException if [startIndex] < 0.
+     * @throws IndexOutOfBoundsException if [startIndex] < 0.
      */
     private fun nextBit(startIndex: Int, lookFor: Boolean): Int {
         if (startIndex < 0) {
@@ -266,7 +266,7 @@ actual constructor(size: Int = ELEMENT_SIZE) {
     /**
      * Returns an index of a next bit which value is `true` after [startIndex] (inclusive).
      * Returns -1 if there is no such bits after [startIndex].
-     * @throws IndexOutOfBoundException if [startIndex] < 0.
+     * @throws IndexOutOfBoundsException if [startIndex] < 0.
      */
     @Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
     public actual fun nextSetBit(startIndex: Int = 0): Int = nextBit(startIndex, true)
@@ -275,7 +275,7 @@ actual constructor(size: Int = ELEMENT_SIZE) {
      * Returns an index of a next bit which value is `false` after [startIndex] (inclusive).
      * Returns [size] if there is no such bits between [startIndex] and [size] - 1 assuming that the set has an infinite
      * sequence of `false` bits after (size - 1)-th.
-     * @throws IndexOutOfBoundException if [startIndex] < 0.
+     * @throws IndexOutOfBoundsException if [startIndex] < 0.
      */
     @Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
     public actual fun nextClearBit(startIndex: Int = 0): Int = nextBit(startIndex, false)
@@ -329,7 +329,7 @@ actual constructor(size: Int = ELEMENT_SIZE) {
      * Returns the biggest index of a bit which value is `true` before [startIndex] (inclusive).
      * Returns -1 if there is no such bits before [startIndex] or if [startIndex] == -1.
      * If [startIndex] >= size will search from (size - 1)-th bit.
-     * @throws IndexOutOfBoundException if [startIndex] < -1.
+     * @throws IndexOutOfBoundsException if [startIndex] < -1.
      */
     public fun previousSetBit(startIndex: Int): Int = previousBit(startIndex, true)
 
@@ -338,7 +338,7 @@ actual constructor(size: Int = ELEMENT_SIZE) {
      * Returns -1 if there is no such bits before [startIndex] or if [startIndex] == -1.
      * If [startIndex] >= size will return [startIndex] assuming that the set has an infinite
      * sequence of `false` bits after (size - 1)-th.
-     * @throws IndexOutOfBoundException if [startIndex] < -1.
+     * @throws IndexOutOfBoundsException if [startIndex] < -1.
      */
     public fun previousClearBit(startIndex: Int): Int = previousBit(startIndex, false)
 

libraries/stdlib/jvm/src/kotlin/text/StringsJVM.kt

@@ -570,7 +570,7 @@ public inline fun String(stringBuilder: java.lang.StringBuilder): String =
  * for more details on function's behavior.
  *
  * @param index the index of [Char] whose codepoint value is needed.
- * @throws IndexOutOfBoundsException if the [index] is negative or greater or equal to [length] of this string.
+ * @throws IndexOutOfBoundsException if the [index] is negative or greater or equal to [length][String.length] of this string.
  *
  * @sample samples.text.StringsJvmSpecific.codePointAt
  */
@@ -585,7 +585,7 @@ public inline fun String.codePointAt(index: Int): Int = (this as java.lang.Strin
  * for more details on function's behavior.
  *
  * @param index the index of a [Char] which follows a codepoint value that will be returned.
- * @throws IndexOutOfBoundsException if the [index] is less than 1, or exceeds the [length] of this string.
+ * @throws IndexOutOfBoundsException if the [index] is less than 1, or exceeds the [length][String.length] of this string.
  *
  * @sample samples.text.StringsJvmSpecific.codePointBefore
  */
@@ -602,7 +602,7 @@ public inline fun String.codePointBefore(index: Int): Int = (this as java.lang.S
  * @param beginIndex the index of a [Char] corresponding to a beginning of the text range (inclusive).
  * @param endIndex the index of a [Char] corresponding to an end of the text range (exclusive).
  *
- * @throws IndexOutOfBoundsException when either of the indices is negative, exceeds [length] of this string, or
+ * @throws IndexOutOfBoundsException when either of the indices is negative, exceeds [length][String.length] of this string, or
  *     when [beginIndex] is greater than [endIndex].
  *
  * @sample samples.text.StringsJvmSpecific.codePointCount

libraries/stdlib/native-wasm/src/kotlin/native/BitSet.kt

@@ -34,15 +34,15 @@ internal expect class BitSet constructor(size: Int = BIT_SET_ELEMENT_SIZE) {
     /**
      * Returns an index of a next bit which value is `true` after [startIndex] (inclusive).
      * Returns -1 if there is no such bits after [startIndex].
-     * @throws IndexOutOfBoundException if [startIndex] < 0.
+     * @throws IndexOutOfBoundsException if [startIndex] < 0.
      */
     fun nextSetBit(startIndex: Int = 0): Int
 
     /**
      * Returns an index of a next bit which value is `false` after [startIndex] (inclusive).
      * Returns [size] if there is no such bits between [startIndex] and [size] - 1 assuming that the set has an infinite
      * sequence of `false` bits after (size - 1)-th.
-     * @throws IndexOutOfBoundException if [startIndex] < 0.
+     * @throws IndexOutOfBoundsException if [startIndex] < 0.
      */
     fun nextClearBit(startIndex: Int = 0): Int
 

libraries/stdlib/src/kotlin/concurrent/atomics/AtomicArrays.common.kt

@@ -20,7 +20,8 @@ import kotlin.internal.InlineOnly
  * When targeting the Native backend, [AtomicIntArray] stores an [IntArray] and atomically updates it's elements.
  * For additional details about atomicity guarantees for reads and writes see [kotlin.concurrent.Volatile].
  *
- * When targeting the JVM, instances of [AtomicIntArray] are represented by [java.util.concurrent.atomic.AtomicIntegerArray].
+ * When targeting the JVM, instances of [AtomicIntArray] are represented by
+ * [java.util.concurrent.atomic.AtomicIntegerArray](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicIntegerArray.html).
  * For details about guarantees of volatile accesses and updates of atomics refer to The Java Language Specification (17.4 Memory Model).
  *
  * For JS and Wasm [AtomicIntArray] is implemented trivially and is not thread-safe since these platforms do not support multi-threading.
@@ -288,7 +289,8 @@ public expect inline fun AtomicIntArray.fetchAndUpdateAt(index: Int, transform:
  * When targeting the Native backend, [AtomicLongArray] stores a [LongArray] and atomically updates it's elements.
  * For additional details about atomicity guarantees for reads and writes see [kotlin.concurrent.Volatile].
  *
- * When targeting the JVM, instances of [AtomicLongArray] are represented by [java.util.concurrent.atomic.AtomicLongArray].
+ * When targeting the JVM, instances of [AtomicLongArray] are represented by
+ * [java.util.concurrent.atomic.AtomicLongArray](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicLongArray.html).
  * For details about guarantees of volatile accesses and updates of atomics refer to The Java Language Specification (17.4 Memory Model).
  *
  * For JS and Wasm [AtomicLongArray] is implemented trivially and is not thread-safe since these platforms do not support multi-threading.
@@ -555,7 +557,8 @@ public expect inline fun AtomicLongArray.fetchAndUpdateAt(index: Int, transform:
  * When targeting the Native backend, [AtomicArray] stores an [Array] with elements of type [T] and atomically updates it's elements.
  * For additional details about atomicity guarantees for reads and writes see [kotlin.concurrent.Volatile].
  *
- * When targeting the JVM, instances of [AtomicArray] are represented by [java.util.concurrent.atomic.AtomicReferenceArray].
+ * When targeting the JVM, instances of [AtomicArray] are represented by
+ * [java.util.concurrent.atomic.AtomicReferenceArray](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReferenceArray.html).
  * For details about guarantees of volatile accesses and updates of atomics refer to The Java Language Specification (17.4 Memory Model).
  *
  * For JS and Wasm [AtomicArray] is implemented trivially and is not thread-safe since these platforms do not support multi-threading.
@@ -567,7 +570,6 @@ public expect class AtomicArray<T> {
     /**
      * Creates a new [AtomicArray] filled with elements of the given [array].
      *
-     * @see atomicArrayOf
      * @see atomicArrayOfNulls
      *
      * @sample samples.concurrent.atomics.AtomicArray.arrCons
@@ -654,7 +656,6 @@ public expect class AtomicArray<T> {
  *
  * @throws RuntimeException if the specified [size] is negative.
  *
- * @see atomicArrayOf
  * @see atomicArrayOfNulls
  *
  * @sample samples.concurrent.atomics.AtomicArray.initCons

libraries/stdlib/src/kotlin/concurrent/atomics/Atomics.common.kt

@@ -20,7 +20,8 @@ import kotlin.internal.InlineOnly
  * When targeting the Native backend, [AtomicInt] stores a volatile [Int] variable and atomically updates it.
  * For additional details about atomicity guarantees for reads and writes see [kotlin.concurrent.Volatile].
  *
- * When targeting the JVM, instances of [AtomicInt] are represented by [java.util.concurrent.atomic.AtomicInteger].
+ * When targeting the JVM, instances of [AtomicInt] are represented by
+ * [java.util.concurrent.atomic.AtomicInteger](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicInteger.html).
  * For details about guarantees of volatile accesses and updates of atomics refer to The Java Language Specification (17.4 Memory Model).
  *
  * For JS and Wasm [AtomicInt] is implemented trivially and is not thread-safe since these platforms do not support multi-threading.
@@ -238,7 +239,8 @@ public expect inline fun AtomicInt.updateAndFetch(transform: (Int) -> Int): Int
  * When targeting the Native backend, [AtomicLong] stores a volatile [Long] variable and atomically updates it.
  * For additional details about atomicity guarantees for reads and writes see [kotlin.concurrent.Volatile].
  *
- * When targeting the JVM, instances of [AtomicLong] are represented by [java.util.concurrent.atomic.AtomicLong].
+ * When targeting the JVM, instances of [AtomicLong] are represented by
+ * [java.util.concurrent.atomic.AtomicLong](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicLong.html).
  * For details about guarantees of volatile accesses and updates of atomics refer to The Java Language Specification (17.4 Memory Model).
  *
  * For JS and Wasm [AtomicLong] is implemented trivially and is not thread-safe since these platforms do not support multi-threading.
@@ -455,7 +457,8 @@ public expect inline fun AtomicLong.updateAndFetch(transform: (Long) -> Long): L
  * When targeting the Native backend, [AtomicBoolean] stores a volatile [Boolean] variable and atomically updates it.
  * For additional details about atomicity guarantees for reads and writes see [kotlin.concurrent.Volatile].
  *
- * When targeting the JVM, instances of [AtomicBoolean] are represented by [java.util.concurrent.atomic.AtomicInteger].
+ * When targeting the JVM, instances of [AtomicBoolean] are represented by
+ * [java.util.concurrent.atomic.AtomicBoolean](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicBoolean.html).
  * For details about guarantees of volatile accesses and updates of atomics refer to The Java Language Specification (17.4 Memory Model).
  *
  * For JS and Wasm [AtomicBoolean] is implemented trivially and is not thread-safe since these platforms do not support multi-threading.
@@ -524,7 +527,8 @@ public expect class AtomicBoolean public constructor(value: Boolean) {
  * When targeting the Native backend, [AtomicReference] stores a volatile variable of type [T] and atomically updates it.
  * For additional details about atomicity guarantees for reads and writes see [kotlin.concurrent.Volatile].
  *
- * When targeting the JVM, instances of [AtomicReference] are represented by [java.util.concurrent.atomic.AtomicReference].
+ * When targeting the JVM, instances of [AtomicReference] are represented by
+ * [java.util.concurrent.atomic.AtomicReference](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html).
  * For details about guarantees of volatile accesses and updates of atomics refer to The Java Language Specification (17.4 Memory Model).
  *
  * For JS and Wasm [AtomicReference] is implemented trivially and is not thread-safe since these platforms do not support multi-threading.

libraries/stdlib/src/kotlin/time/Clocks.kt

@@ -6,7 +6,7 @@
 package kotlin.time
 
 /**
- * Creates a [Clock] that uses the [time mark at the moment of creation][TimeMark.markNow] to determine how [far][TimeMark.elapsedNow]
+ * Creates a [Clock] that uses the [time mark at the moment of creation][TimeSource.markNow] to determine how [far][TimeMark.elapsedNow]
  * the [current moment][Clock.now] is from the [origin].
  *
  * This clock stores the [TimeMark] at the moment of creation, so repeatedly creating [Clock]s from the same [TimeSource] results

libraries/stdlib/wasm/src/kotlin/text/regex/BitSet.kt

@@ -163,7 +163,7 @@ actual constructor(size: Int = ELEMENT_SIZE) {
      * (if [lookFor] == false) bit after [startIndex] (inclusive).
      * Returns -1 (for [lookFor] == true) or [size] (for lookFor == false)
      * if there is no such bits between [startIndex] and [size] - 1.
-     * @throws IndexOutOfBoundException if [startIndex] < 0.
+     * @throws IndexOutOfBoundsException if [startIndex] < 0.
      */
     private fun nextBit(startIndex: Int, lookFor: Boolean): Int {
         if (startIndex < 0) {
@@ -197,7 +197,7 @@ actual constructor(size: Int = ELEMENT_SIZE) {
     /**
      * Returns an index of a next bit which value is `true` after [startIndex] (inclusive).
      * Returns -1 if there is no such bits after [startIndex].
-     * @throws IndexOutOfBoundException if [startIndex] < 0.
+     * @throws IndexOutOfBoundsException if [startIndex] < 0.
      */
     @Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
     actual fun nextSetBit(startIndex: Int = 0): Int = nextBit(startIndex, true)