diff --git a/kotlin-native/runtime/build.gradle.kts b/kotlin-native/runtime/build.gradle.kts index 089826238c5..8125bc64c12 100644 --- a/kotlin-native/runtime/build.gradle.kts +++ b/kotlin-native/runtime/build.gradle.kts @@ -404,8 +404,6 @@ val stdLibSrcDirs = interopSrcDirs + listOf( project(":kotlin-stdlib-common").file("../native-wasm/src/") ) -val args = listOf(/* -Werror (TODO: check) */) - lateinit var stdlibBuildTask: TaskProvider konanArtifacts { @@ -418,8 +416,9 @@ konanArtifacts { noDefaultLibs(true) noEndorsedLibs(true) - extraOpts(args + project.globalBuildArgs) + extraOpts(project.globalBuildArgs) extraOpts( + "-Werror", "-module-name", "stdlib", "-opt-in=kotlin.RequiresOptIn", "-opt-in=kotlin.contracts.ExperimentalContracts", diff --git a/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/Future.kt b/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/Future.kt index 218c6730ff9..3b130c6961f 100644 --- a/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/Future.kt +++ b/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/Future.kt @@ -26,7 +26,7 @@ enum class FutureState(val value: Int) { * Class representing abstract computation, whose result may become available in the future. */ @Suppress("NON_PUBLIC_PRIMARY_CONSTRUCTOR_OF_INLINE_CLASS") -public inline class Future @PublishedApi internal constructor(val id: Int) { +public value class Future @PublishedApi internal constructor(val id: Int) { /** * Blocks execution until the future is ready. * diff --git a/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/Worker.kt b/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/Worker.kt index a20eba64fb8..2d16eedc0b5 100644 --- a/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/Worker.kt +++ b/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/Worker.kt @@ -27,7 +27,7 @@ import kotlinx.cinterop.* * Class representing worker. */ @Suppress("NON_PUBLIC_PRIMARY_CONSTRUCTOR_OF_INLINE_CLASS") -public inline class Worker @PublishedApi internal constructor(val id: Int) { +public value class Worker @PublishedApi internal constructor(val id: Int) { companion object { /** * Start new scheduling primitive, such as thread, to accept new tasks via `execute` interface. diff --git a/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/KClassImpl.kt b/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/KClassImpl.kt index 0b06ec4ebf1..4bbd014dba5 100644 --- a/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/KClassImpl.kt +++ b/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/KClassImpl.kt @@ -12,6 +12,7 @@ internal class KClassImpl(private val typeInfo: NativePtr) : KClass @ExportForCompiler @ConstantConstructorIntrinsic("KCLASS_IMPL") + @Suppress("UNREACHABLE_CODE") constructor() : this(TODO("This is intrinsic constructor and it shouldn't be used directly")) // TODO: consider replacing '$' by another delimeter that can't be used in class name specified with backticks (``) diff --git a/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/KTypeImpl.kt b/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/KTypeImpl.kt index 64bfe938a61..1e2ae28325f 100644 --- a/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/KTypeImpl.kt +++ b/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/KTypeImpl.kt @@ -57,6 +57,7 @@ internal class KTypeImpl( @ExportForCompiler @ConstantConstructorIntrinsic("KTYPE_IMPL") + @Suppress("UNREACHABLE_CODE") constructor() : this(null, TODO("This is intrinsic constructor and it shouldn't be used directly"), false) override fun equals(other: Any?) = diff --git a/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/test/GTestLogger.kt b/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/test/GTestLogger.kt index 432a7c7ed01..72f13fa3b67 100644 --- a/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/test/GTestLogger.kt +++ b/kotlin-native/runtime/src/main/kotlin/kotlin/native/internal/test/GTestLogger.kt @@ -8,7 +8,7 @@ package kotlin.native.internal.test internal class GTestLogger : TestLoggerWithStatistics() { private val Collection.totalTestsNotIgnored: Int - get() = asSequence().filter { !it.ignored }.sumBy { it.testCases.values.count { !it.ignored } } + get() = asSequence().filter { !it.ignored }.sumOf { it.testCases.values.count { !it.ignored } } private val Collection.totalNotIgnored: Int get() = filter { !it.ignored }.size diff --git a/libraries/stdlib/native-wasm/src/kotlin/collections/ArrayList.kt b/libraries/stdlib/native-wasm/src/kotlin/collections/ArrayList.kt index b53896dac01..12aac18acbb 100644 --- a/libraries/stdlib/native-wasm/src/kotlin/collections/ArrayList.kt +++ b/libraries/stdlib/native-wasm/src/kotlin/collections/ArrayList.kt @@ -6,12 +6,12 @@ package kotlin.collections actual class ArrayList private constructor( - private var array: Array, - private var offset: Int, - private var length: Int, - private var isReadOnly: Boolean, - private val backing: ArrayList?, - private val root: ArrayList? + private var backingArray: Array, + private var offset: Int, + private var length: Int, + private var isReadOnly: Boolean, + private val backingList: ArrayList?, + private val root: ArrayList? ) : MutableList, RandomAccess, AbstractMutableList() { actual constructor() : this(10) @@ -25,7 +25,7 @@ actual class ArrayList private constructor( @PublishedApi internal fun build(): List { - if (backing != null) throw IllegalStateException() // just in case somebody casts subList to ArrayList + if (backingList != null) throw IllegalStateException() // just in case somebody casts subList to ArrayList checkIsMutable() isReadOnly = true return this @@ -38,21 +38,21 @@ actual class ArrayList private constructor( override actual fun get(index: Int): E { checkElementIndex(index) - return array[offset + index] + return backingArray[offset + index] } override actual operator fun set(index: Int, element: E): E { checkIsMutable() checkElementIndex(index) - val old = array[offset + index] - array[offset + index] = element + val old = backingArray[offset + index] + backingArray[offset + index] = element return old } override actual fun indexOf(element: E): Int { var i = 0 while (i < length) { - if (array[offset + i] == element) return i + if (backingArray[offset + i] == element) return i i++ } return -1 @@ -61,7 +61,7 @@ actual class ArrayList private constructor( override actual fun lastIndexOf(element: E): Int { var i = length - 1 while (i >= 0) { - if (array[offset + i] == element) return i + if (backingArray[offset + i] == element) return i i-- } return -1 @@ -132,21 +132,21 @@ actual class ArrayList private constructor( override actual fun subList(fromIndex: Int, toIndex: Int): MutableList { checkRangeIndexes(fromIndex, toIndex) - return ArrayList(array, offset + fromIndex, toIndex - fromIndex, isReadOnly, this, root ?: this) + return ArrayList(backingArray, offset + fromIndex, toIndex - fromIndex, isReadOnly, this, root ?: this) } actual fun trimToSize() { - if (backing != null) throw IllegalStateException() // just in case somebody casts subList to ArrayList - if (length < array.size) - array = array.copyOfUninitializedElements(length) + if (backingList != null) throw IllegalStateException() // just in case somebody casts subList to ArrayList + if (length < backingArray.size) + backingArray = backingArray.copyOfUninitializedElements(length) } final actual fun ensureCapacity(minCapacity: Int) { - if (backing != null) throw IllegalStateException() // just in case somebody casts subList to ArrayList + if (backingList != null) throw IllegalStateException() // just in case somebody casts subList to ArrayList if (minCapacity < 0) throw OutOfMemoryError() // overflow - if (minCapacity > array.size) { - val newSize = ArrayDeque.newCapacity(array.size, minCapacity) - array = array.copyOfUninitializedElements(newSize) + if (minCapacity > backingArray.size) { + val newSize = ArrayDeque.newCapacity(backingArray.size, minCapacity) + backingArray = backingArray.copyOfUninitializedElements(newSize) } } @@ -156,32 +156,32 @@ actual class ArrayList private constructor( } override fun hashCode(): Int { - return array.subarrayContentHashCode(offset, length) + return backingArray.subarrayContentHashCode(offset, length) } override fun toString(): String { @Suppress("DEPRECATION_ERROR") - return array.subarrayContentToString(offset, length) + return backingArray.subarrayContentToString(offset, length) } @Suppress("UNCHECKED_CAST") - override fun toArray(destination: Array): Array { - if (destination.size < length) { - return array.copyOfRange(fromIndex = offset, toIndex = offset + length) as Array + override fun toArray(array: Array): Array { + if (array.size < length) { + return backingArray.copyOfRange(fromIndex = offset, toIndex = offset + length) as Array } - (array as Array).copyInto(destination, 0, startIndex = offset, endIndex = offset + length) + (backingArray as Array).copyInto(array, 0, startIndex = offset, endIndex = offset + length) - if (destination.size > length) { - destination[length] = null as T // null-terminate + if (array.size > length) { + array[length] = null as T // null-terminate } - return destination + return array } override fun toArray(): Array { @Suppress("UNCHECKED_CAST") - return array.copyOfRange(fromIndex = offset, toIndex = offset + length) as Array + return backingArray.copyOfRange(fromIndex = offset, toIndex = offset + length) as Array } // ---------------------------- private ---------------------------- @@ -216,85 +216,85 @@ actual class ArrayList private constructor( } private fun contentEquals(other: List<*>): Boolean { - return array.subarrayContentEquals(offset, length, other) + return backingArray.subarrayContentEquals(offset, length, other) } private fun insertAtInternal(i: Int, n: Int) { ensureExtraCapacity(n) - array.copyInto(array, startIndex = i, endIndex = offset + length, destinationOffset = i + n) + backingArray.copyInto(backingArray, startIndex = i, endIndex = offset + length, destinationOffset = i + n) length += n } private fun addAtInternal(i: Int, element: E) { - if (backing != null) { - backing.addAtInternal(i, element) - array = backing.array + if (backingList != null) { + backingList.addAtInternal(i, element) + backingArray = backingList.backingArray length++ } else { insertAtInternal(i, 1) - array[i] = element + backingArray[i] = element } } private fun addAllInternal(i: Int, elements: Collection, n: Int) { - if (backing != null) { - backing.addAllInternal(i, elements, n) - array = backing.array + if (backingList != null) { + backingList.addAllInternal(i, elements, n) + backingArray = backingList.backingArray length += n } else { insertAtInternal(i, n) var j = 0 val it = elements.iterator() while (j < n) { - array[i + j] = it.next() + backingArray[i + j] = it.next() j++ } } } private fun removeAtInternal(i: Int): E { - if (backing != null) { - val old = backing.removeAtInternal(i) + if (backingList != null) { + val old = backingList.removeAtInternal(i) length-- return old } else { - val old = array[i] - array.copyInto(array, startIndex = i + 1, endIndex = offset + length, destinationOffset = i) - array.resetAt(offset + length - 1) + val old = backingArray[i] + backingArray.copyInto(backingArray, startIndex = i + 1, endIndex = offset + length, destinationOffset = i) + backingArray.resetAt(offset + length - 1) length-- return old } } private fun removeRangeInternal(rangeOffset: Int, rangeLength: Int) { - if (backing != null) { - backing.removeRangeInternal(rangeOffset, rangeLength) + if (backingList != null) { + backingList.removeRangeInternal(rangeOffset, rangeLength) } else { - array.copyInto(array, startIndex = rangeOffset + rangeLength, endIndex = length, destinationOffset = rangeOffset) - array.resetRange(fromIndex = length - rangeLength, toIndex = length) + backingArray.copyInto(backingArray, startIndex = rangeOffset + rangeLength, endIndex = length, destinationOffset = rangeOffset) + backingArray.resetRange(fromIndex = length - rangeLength, toIndex = length) } length -= rangeLength } /** Retains elements if [retain] == true and removes them it [retain] == false. */ private fun retainOrRemoveAllInternal(rangeOffset: Int, rangeLength: Int, elements: Collection, retain: Boolean): Int { - if (backing != null) { - val removed = backing.retainOrRemoveAllInternal(rangeOffset, rangeLength, elements, retain) + if (backingList != null) { + val removed = backingList.retainOrRemoveAllInternal(rangeOffset, rangeLength, elements, retain) length -= removed return removed } else { var i = 0 var j = 0 while (i < rangeLength) { - if (elements.contains(array[rangeOffset + i]) == retain) { - array[rangeOffset + j++] = array[rangeOffset + i++] + if (elements.contains(backingArray[rangeOffset + i]) == retain) { + backingArray[rangeOffset + j++] = backingArray[rangeOffset + i++] } else { i++ } } val removed = rangeLength - j - array.copyInto(array, startIndex = rangeOffset + rangeLength, endIndex = length, destinationOffset = rangeOffset + j) - array.resetRange(fromIndex = length - removed, toIndex = length) + backingArray.copyInto(backingArray, startIndex = rangeOffset + rangeLength, endIndex = length, destinationOffset = rangeOffset + j) + backingArray.resetRange(fromIndex = length - removed, toIndex = length) length -= removed return removed } @@ -320,13 +320,13 @@ actual class ArrayList private constructor( override fun previous(): E { if (index <= 0) throw NoSuchElementException() lastIndex = --index - return list.array[list.offset + lastIndex] + return list.backingArray[list.offset + lastIndex] } override fun next(): E { if (index >= list.length) throw NoSuchElementException() lastIndex = index++ - return list.array[list.offset + lastIndex] + return list.backingArray[list.offset + lastIndex] } override fun set(element: E) {