JS: fixed <Type>Array.iterator methods; added -Xtypedarray compiler key
The <Type>Array.iterator used to lack next<Type>() method (KT-16626). The -Xtypedarray compiler key enables translation of primitive arrays to TypedArrays, and primitive array`is`-checks (KT-15358, KT-14007, KT-14614, KT-16056).
This commit is contained in:
Anton Bannykh
+4
@@ -71,6 +71,10 @@ public class K2JSCompilerArguments extends CommonCompilerArguments {
|
||||
@ValueDescription("<path>")
|
||||
public String outputPostfix;
|
||||
|
||||
@GradleOption(DefaultValues.BooleanFalseDefault.class)
|
||||
@Argument(value = "Xtypedarrays", description = "Translate primitive arrays to JS typed arrays")
|
||||
public boolean typedArrays;
|
||||
|
||||
@NotNull
|
||||
public static K2JSCompilerArguments createDefaultInstance() {
|
||||
K2JSCompilerArguments arguments = new K2JSCompilerArguments();
|
||||
|
||||
@@ -286,6 +286,10 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
|
||||
ContainerUtil.addAllNotNull(libraries, arguments.libraries.split(File.pathSeparator));
|
||||
}
|
||||
|
||||
if (arguments.typedArrays) {
|
||||
configuration.put(JSConfigurationKeys.TYPED_ARRAYS_ENABLED, true);
|
||||
}
|
||||
|
||||
configuration.put(JSConfigurationKeys.LIBRARIES, libraries);
|
||||
|
||||
String moduleKindName = arguments.moduleKind;
|
||||
|
||||
+1
@@ -1,5 +1,6 @@
|
||||
Usage: kotlinc-js <options> <source files>
|
||||
where advanced options include:
|
||||
-Xtypedarrays Translate primitive arrays to JS typed arrays
|
||||
-Xno-inline Disable method inlining
|
||||
-Xrepeat <count> Repeat compilation (for performance analysis)
|
||||
-Xskip-metadata-version-check Load classes with bad metadata version anyway (incl. pre-release classes)
|
||||
|
||||
+1
-2
@@ -1,5 +1,4 @@
|
||||
// TODO: muted automatically, investigate should it be ran for JS or not
|
||||
// IGNORE_BACKEND: JS
|
||||
// IGNORE_BACKEND_WITHOUT_CHECK: JS
|
||||
|
||||
//test [], get and iterator calls
|
||||
fun test(createIntNotLong: Boolean): String {
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
// TODO: muted automatically, investigate should it be ran for JS or not
|
||||
// IGNORE_BACKEND: JS
|
||||
|
||||
fun box(): String {
|
||||
val a = ByteArray(5)
|
||||
val x = a.iterator()
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
// TODO: muted automatically, investigate should it be ran for JS or not
|
||||
// IGNORE_BACKEND: JS
|
||||
|
||||
fun box(): String {
|
||||
val a = LongArray(5)
|
||||
val x = a.iterator()
|
||||
|
||||
+2
-2
@@ -1,6 +1,6 @@
|
||||
//KT-2997 Automatically cast error (Array)
|
||||
// IGNORE_BACKEND: JS
|
||||
// Unmute when JS implements primitive arrays via TypeArray
|
||||
// IGNORE_BACKEND_WITHOUT_CHECK: JS
|
||||
// Unmute when JS implements primitive arrays via TypedArray
|
||||
|
||||
fun foo(a: Any): Int {
|
||||
if (a is IntArray) {
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
// IGNORE_BACKEND_WITHOUT_CHECK: JS
|
||||
|
||||
fun test(b: Boolean): String {
|
||||
val a = if (b) IntArray(5) else LongArray(5)
|
||||
if (a is IntArray) {
|
||||
|
||||
@@ -0,0 +1,196 @@
|
||||
// WITH_RUNTIME
|
||||
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFails
|
||||
|
||||
fun box(): String {
|
||||
assertTrue(eqBoolean(booleanArrayOf(false), BooleanArray(1)))
|
||||
assertTrue(eqBoolean(booleanArrayOf(false, true, false), BooleanArray(3) { it % 2 != 0 }))
|
||||
assertTrue(eqBoolean(booleanArrayOf(true), booleanArrayOf(true).copyOf()))
|
||||
assertTrue(eqBoolean(booleanArrayOf(true, false), booleanArrayOf(true).copyOf(2)))
|
||||
assertTrue(eqBoolean(booleanArrayOf(true), booleanArrayOf(true, true).copyOf(1)))
|
||||
assertTrue(eqBoolean(booleanArrayOf(false, true), booleanArrayOf(false) + true))
|
||||
assertTrue(eqBoolean(booleanArrayOf(false, true, false), booleanArrayOf(false) + listOf(true, false)))
|
||||
assertTrue(eqBoolean(booleanArrayOf(true, false), booleanArrayOf(false, true, false, true).copyOfRange(1, 3)))
|
||||
assertTrue(eqBoolean(booleanArrayOf(false, true, false, true), customBooleanArrayOf(false, *booleanArrayOf(true, false), true)))
|
||||
assertTrue(booleanArrayOf(true).iterator() is BooleanIterator)
|
||||
assertEquals(true, booleanArrayOf(true).iterator().nextBoolean())
|
||||
assertEquals(true, booleanArrayOf(true).iterator().next())
|
||||
assertFalse(booleanArrayOf().iterator().hasNext())
|
||||
assertTrue(assertFails { booleanArrayOf().iterator().next() } is IndexOutOfBoundsException)
|
||||
|
||||
assertTrue(eqByte(byteArrayOf(0), ByteArray(1)))
|
||||
assertTrue(eqByte(byteArrayOf(1, 2, 3), ByteArray(3) { (it + 1).toByte() }))
|
||||
assertTrue(eqByte(byteArrayOf(1), byteArrayOf(1).copyOf()))
|
||||
assertTrue(eqByte(byteArrayOf(1, 0), byteArrayOf(1).copyOf(2)))
|
||||
assertTrue(eqByte(byteArrayOf(1), byteArrayOf(1, 2).copyOf(1)))
|
||||
assertTrue(eqByte(byteArrayOf(1, 2), byteArrayOf(1) + 2))
|
||||
assertTrue(eqByte(byteArrayOf(1, 2, 3), byteArrayOf(1) + listOf(2.toByte(), 3.toByte())))
|
||||
assertTrue(eqByte(byteArrayOf(2, 3), byteArrayOf(1, 2, 3, 4).copyOfRange(1, 3)))
|
||||
assertTrue(eqByte(byteArrayOf(1, 2, 3, 4), customByteArrayOf(1.toByte(), *byteArrayOf(2, 3), 4.toByte())))
|
||||
assertTrue(byteArrayOf(1).iterator() is ByteIterator)
|
||||
assertEquals(1, byteArrayOf(1).iterator().nextByte())
|
||||
assertEquals(1, byteArrayOf(1).iterator().next())
|
||||
assertFalse(byteArrayOf().iterator().hasNext())
|
||||
assertTrue(assertFails { byteArrayOf().iterator().next() } is IndexOutOfBoundsException)
|
||||
|
||||
assertTrue(eqShort(shortArrayOf(0), ShortArray(1)))
|
||||
assertTrue(eqShort(shortArrayOf(1, 2, 3), ShortArray(3) { (it + 1).toShort() }))
|
||||
assertTrue(eqShort(shortArrayOf(1), shortArrayOf(1).copyOf()))
|
||||
assertTrue(eqShort(shortArrayOf(1, 0), shortArrayOf(1).copyOf(2)))
|
||||
assertTrue(eqShort(shortArrayOf(1), shortArrayOf(1, 2).copyOf(1)))
|
||||
assertTrue(eqShort(shortArrayOf(1, 2), shortArrayOf(1) + 2))
|
||||
assertTrue(eqShort(shortArrayOf(1, 2, 3), shortArrayOf(1) + listOf(2.toShort(), 3.toShort())))
|
||||
assertTrue(eqShort(shortArrayOf(2, 3), shortArrayOf(1, 2, 3, 4).copyOfRange(1, 3)))
|
||||
assertTrue(eqShort(shortArrayOf(1, 2, 3, 4), customShortArrayOf(1.toShort(), *shortArrayOf(2, 3), 4.toShort())))
|
||||
assertTrue(shortArrayOf(1).iterator() is ShortIterator)
|
||||
assertEquals(1, shortArrayOf(1).iterator().nextShort())
|
||||
assertEquals(1, shortArrayOf(1).iterator().next())
|
||||
assertFalse(shortArrayOf().iterator().hasNext())
|
||||
assertTrue(assertFails { shortArrayOf().iterator().next() } is IndexOutOfBoundsException)
|
||||
|
||||
assertTrue(eqChar(charArrayOf(0.toChar()), CharArray(1)))
|
||||
assertTrue(eqChar(charArrayOf('a', 'b', 'c'), CharArray(3) { 'a' + it }))
|
||||
assertTrue(eqChar(charArrayOf('a'), charArrayOf('a').copyOf()))
|
||||
assertTrue(eqChar(charArrayOf('a', 0.toChar()), charArrayOf('a').copyOf(2)))
|
||||
assertTrue(eqChar(charArrayOf('a'), charArrayOf('a', 'b').copyOf(1)))
|
||||
assertTrue(eqChar(charArrayOf('a', 'b'), charArrayOf('a') + 'b'))
|
||||
assertTrue(eqChar(charArrayOf('a', 'b', 'c'), charArrayOf('a') + listOf('b', 'c')))
|
||||
assertTrue(eqChar(charArrayOf('b', 'c'), charArrayOf('a', 'b', 'c', 'd').copyOfRange(1, 3)))
|
||||
assertTrue(eqChar(charArrayOf('a', 'b', 'c', 'd'), customCharArrayOf('a', *charArrayOf('b', 'c'), 'd')))
|
||||
assertTrue(charArrayOf('a').iterator() is CharIterator)
|
||||
assertEquals('a', charArrayOf('a').iterator().nextChar())
|
||||
assertEquals('a', charArrayOf('a').iterator().next())
|
||||
assertFalse(charArrayOf().iterator().hasNext())
|
||||
assertTrue(assertFails { charArrayOf().iterator().next() } is IndexOutOfBoundsException)
|
||||
|
||||
assertTrue(eqInt(intArrayOf(0), IntArray(1)))
|
||||
assertTrue(eqInt(intArrayOf(1, 2, 3), IntArray(3) { it + 1 }))
|
||||
assertTrue(eqInt(intArrayOf(1), intArrayOf(1).copyOf()))
|
||||
assertTrue(eqInt(intArrayOf(1, 0), intArrayOf(1).copyOf(2)))
|
||||
assertTrue(eqInt(intArrayOf(1), intArrayOf(1, 2).copyOf(1)))
|
||||
assertTrue(eqInt(intArrayOf(1, 2), intArrayOf(1) + 2))
|
||||
assertTrue(eqInt(intArrayOf(1, 2, 3), intArrayOf(1) + listOf(2, 3)))
|
||||
assertTrue(eqInt(intArrayOf(2, 3), intArrayOf(1, 2, 3, 4).copyOfRange(1, 3)))
|
||||
assertTrue(eqInt(intArrayOf(1, 2, 3, 4), customIntArrayOf(1, *intArrayOf(2, 3), 4)))
|
||||
assertTrue(intArrayOf(1).iterator() is IntIterator)
|
||||
assertEquals(1, intArrayOf(1).iterator().nextInt())
|
||||
assertEquals(1, intArrayOf(1).iterator().next())
|
||||
assertFalse(intArrayOf().iterator().hasNext())
|
||||
assertTrue(assertFails { intArrayOf().iterator().next() } is IndexOutOfBoundsException)
|
||||
|
||||
assertTrue(eqFloat(floatArrayOf(0f), FloatArray(1)))
|
||||
assertTrue(eqFloat(floatArrayOf(1f, 2f, 3f), FloatArray(3) { (it + 1).toFloat() }))
|
||||
assertTrue(eqFloat(floatArrayOf(1f), floatArrayOf(1f).copyOf()))
|
||||
assertTrue(eqFloat(floatArrayOf(1f, 0f), floatArrayOf(1f).copyOf(2)))
|
||||
assertTrue(eqFloat(floatArrayOf(1f), floatArrayOf(1f, 2f).copyOf(1)))
|
||||
assertTrue(eqFloat(floatArrayOf(1f, 2f), floatArrayOf(1f) + 2f))
|
||||
assertTrue(eqFloat(floatArrayOf(1f, 2f, 3f), floatArrayOf(1f) + listOf(2f, 3f)))
|
||||
assertTrue(eqFloat(floatArrayOf(2f, 3f), floatArrayOf(1f, 2f, 3f, 4f).copyOfRange(1, 3)))
|
||||
assertTrue(eqFloat(floatArrayOf(1f, 2f, 3f, 4f), customFloatArrayOf(1f, *floatArrayOf(2f, 3f), 4f)))
|
||||
assertTrue(floatArrayOf(1f).iterator() is FloatIterator)
|
||||
assertEquals(1f, floatArrayOf(1f).iterator().nextFloat())
|
||||
assertEquals(1f, floatArrayOf(1f).iterator().next())
|
||||
assertFalse(floatArrayOf().iterator().hasNext())
|
||||
assertTrue(assertFails { floatArrayOf().iterator().next() } is IndexOutOfBoundsException)
|
||||
|
||||
assertTrue(eqDouble(doubleArrayOf(0.0), DoubleArray(1)))
|
||||
assertTrue(eqDouble(doubleArrayOf(1.0, 2.0, 3.0), DoubleArray(3) { (it + 1).toDouble() }))
|
||||
assertTrue(eqDouble(doubleArrayOf(1.0), doubleArrayOf(1.0).copyOf()))
|
||||
assertTrue(eqDouble(doubleArrayOf(1.0, 0.0), doubleArrayOf(1.0).copyOf(2)))
|
||||
assertTrue(eqDouble(doubleArrayOf(1.0), doubleArrayOf(1.0, 2.0).copyOf(1)))
|
||||
assertTrue(eqDouble(doubleArrayOf(1.0, 2.0), doubleArrayOf(1.0) + 2.0))
|
||||
assertTrue(eqDouble(doubleArrayOf(1.0, 2.0, 3.0), doubleArrayOf(1.0) + listOf(2.0, 3.0)))
|
||||
assertTrue(eqDouble(doubleArrayOf(2.0, 3.0), doubleArrayOf(1.0, 2.0, 3.0, 4.0).copyOfRange(1, 3)))
|
||||
assertTrue(eqDouble(doubleArrayOf(1.0, 2.0, 3.0, 4.0), customDoubleArrayOf(1.0, *doubleArrayOf(2.0, 3.0), 4.0)))
|
||||
assertTrue(doubleArrayOf(1.0).iterator() is DoubleIterator)
|
||||
assertEquals(1.0, doubleArrayOf(1.0).iterator().nextDouble())
|
||||
assertEquals(1.0, doubleArrayOf(1.0).iterator().next())
|
||||
assertFalse(doubleArrayOf().iterator().hasNext())
|
||||
assertTrue(assertFails { doubleArrayOf().iterator().next() } is IndexOutOfBoundsException)
|
||||
|
||||
assertTrue(eqLong(longArrayOf(0), LongArray(1)))
|
||||
assertTrue(eqLong(longArrayOf(1, 2, 3), LongArray(3) { it + 1L }))
|
||||
assertTrue(eqLong(longArrayOf(1), longArrayOf(1).copyOf()))
|
||||
assertTrue(eqLong(longArrayOf(1, 0), longArrayOf(1).copyOf(2)))
|
||||
assertTrue(eqLong(longArrayOf(1), longArrayOf(1, 2).copyOf(1)))
|
||||
assertTrue(eqLong(longArrayOf(1, 2), longArrayOf(1) + 2))
|
||||
assertTrue(eqLong(longArrayOf(1, 2, 3), longArrayOf(1) + listOf(2L, 3L)))
|
||||
assertTrue(eqLong(longArrayOf(2, 3), longArrayOf(1, 2, 3, 4).copyOfRange(1, 3)))
|
||||
assertTrue(eqLong(longArrayOf(1, 2, 3, 4), customLongArrayOf(1L, *longArrayOf(2, 3), 4L)))
|
||||
assertTrue(longArrayOf(1).iterator() is LongIterator)
|
||||
assertEquals(1L, longArrayOf(1).iterator().nextLong())
|
||||
assertEquals(1L, longArrayOf(1).iterator().next())
|
||||
assertFalse(longArrayOf().iterator().hasNext())
|
||||
assertTrue(assertFails { longArrayOf().iterator().next() } is IndexOutOfBoundsException)
|
||||
|
||||
// If `is` checks work...
|
||||
if (intArrayOf() is IntArray) {
|
||||
assertTrue(booleanArrayOf(false) is BooleanArray)
|
||||
assertTrue(byteArrayOf(0) is ByteArray)
|
||||
assertTrue(shortArrayOf(0) is ShortArray)
|
||||
assertTrue(charArrayOf('a') is CharArray)
|
||||
assertTrue(intArrayOf(0) is IntArray)
|
||||
assertTrue(floatArrayOf(0f) is FloatArray)
|
||||
assertTrue(doubleArrayOf(0.0) is DoubleArray)
|
||||
assertTrue(longArrayOf(0) is LongArray)
|
||||
}
|
||||
|
||||
// Rhino `instanceof` fails to distinguish TypedArray's
|
||||
if (intArrayOf() is IntArray && (byteArrayOf() as Any) !is IntArray) {
|
||||
assertTrue(checkExactArrayType(booleanArrayOf(false), booleanArray = true))
|
||||
assertTrue(checkExactArrayType(byteArrayOf(0), byteArray = true))
|
||||
assertTrue(checkExactArrayType(shortArrayOf(0), shortArray = true))
|
||||
assertTrue(checkExactArrayType(charArrayOf('a'), charArray = true))
|
||||
assertTrue(checkExactArrayType(intArrayOf(0), intArray = true))
|
||||
assertTrue(checkExactArrayType(floatArrayOf(0f), floatArray = true))
|
||||
assertTrue(checkExactArrayType(doubleArrayOf(0.0), doubleArray = true))
|
||||
assertTrue(checkExactArrayType(longArrayOf(0), longArray = true))
|
||||
assertTrue(checkExactArrayType(arrayOf<Any?>(), array = true))
|
||||
}
|
||||
|
||||
return "OK"
|
||||
}
|
||||
|
||||
fun eqBoolean(expected: BooleanArray, actual: BooleanArray): Boolean = actual.size == expected.size && actual.foldIndexed(true) { i, r, v -> r && expected[i] == v }
|
||||
fun eqByte(expected: ByteArray, actual: ByteArray): Boolean = actual.size == expected.size && actual.foldIndexed(true) { i, r, v -> r && expected[i] == v }
|
||||
fun eqShort(expected: ShortArray, actual: ShortArray): Boolean = actual.size == expected.size && actual.foldIndexed(true) { i, r, v -> r && expected[i] == v }
|
||||
fun eqChar(expected: CharArray, actual: CharArray): Boolean = actual.size == expected.size && actual.foldIndexed(true) { i, r, v -> r && expected[i] == v }
|
||||
fun eqInt(expected: IntArray, actual: IntArray): Boolean = actual.size == expected.size && actual.foldIndexed(true) { i, r, v -> r && expected[i] == v }
|
||||
fun eqLong(expected: LongArray, actual: LongArray): Boolean = actual.size == expected.size && actual.foldIndexed(true) { i, r, v -> r && expected[i] == v }
|
||||
fun eqFloat(expected: FloatArray, actual: FloatArray): Boolean = actual.size == expected.size && actual.foldIndexed(true) { i, r, v -> r && expected[i] == v }
|
||||
fun eqDouble(expected: DoubleArray, actual: DoubleArray): Boolean = actual.size == expected.size && actual.foldIndexed(true) { i, r, v -> r && expected[i] == v }
|
||||
|
||||
fun customBooleanArrayOf(vararg arr: Boolean): BooleanArray = arr
|
||||
fun customByteArrayOf(vararg arr: Byte): ByteArray = arr
|
||||
fun customShortArrayOf(vararg arr: Short): ShortArray = arr
|
||||
fun customCharArrayOf(vararg arr: Char): CharArray = arr
|
||||
fun customIntArrayOf(vararg arr: Int): IntArray = arr
|
||||
fun customFloatArrayOf(vararg arr: Float): FloatArray = arr
|
||||
fun customDoubleArrayOf(vararg arr: Double): DoubleArray = arr
|
||||
fun customLongArrayOf(vararg arr: Long): LongArray = arr
|
||||
|
||||
fun checkExactArrayType(
|
||||
a: Any?,
|
||||
booleanArray: Boolean = false,
|
||||
byteArray: Boolean = false,
|
||||
shortArray: Boolean = false,
|
||||
charArray: Boolean = false,
|
||||
intArray: Boolean = false,
|
||||
longArray: Boolean = false,
|
||||
floatArray: Boolean = false,
|
||||
doubleArray: Boolean = false,
|
||||
array: Boolean = false
|
||||
): Boolean {
|
||||
return a is BooleanArray == booleanArray &&
|
||||
a is ByteArray == byteArray &&
|
||||
a is ShortArray == shortArray &&
|
||||
a is CharArray == charArray &&
|
||||
a is IntArray == intArray &&
|
||||
a is LongArray == longArray &&
|
||||
a is FloatArray == floatArray &&
|
||||
a is DoubleArray == doubleArray &&
|
||||
a is Array<*> == array
|
||||
}
|
||||
@@ -1,3 +1,4 @@
|
||||
// IGNORE_BACKEND_WITHOUT_CHECK: JS
|
||||
// WITH_RUNTIME
|
||||
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
@kotlin.Metadata
|
||||
public final class PrimitiveArraysKt {
|
||||
public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
|
||||
public synthetic static method checkExactArrayType$default(p0: java.lang.Object, p1: boolean, p2: boolean, p3: boolean, p4: boolean, p5: boolean, p6: boolean, p7: boolean, p8: boolean, p9: boolean, p10: int, p11: java.lang.Object): boolean
|
||||
public final static method checkExactArrayType(@org.jetbrains.annotations.Nullable p0: java.lang.Object, p1: boolean, p2: boolean, p3: boolean, p4: boolean, p5: boolean, p6: boolean, p7: boolean, p8: boolean, p9: boolean): boolean
|
||||
public final static @org.jetbrains.annotations.NotNull method customBooleanArrayOf(@org.jetbrains.annotations.NotNull p0: boolean[]): boolean[]
|
||||
public final static @org.jetbrains.annotations.NotNull method customByteArrayOf(@org.jetbrains.annotations.NotNull p0: byte[]): byte[]
|
||||
public final static @org.jetbrains.annotations.NotNull method customCharArrayOf(@org.jetbrains.annotations.NotNull p0: char[]): char[]
|
||||
public final static @org.jetbrains.annotations.NotNull method customDoubleArrayOf(@org.jetbrains.annotations.NotNull p0: double[]): double[]
|
||||
public final static @org.jetbrains.annotations.NotNull method customFloatArrayOf(@org.jetbrains.annotations.NotNull p0: float[]): float[]
|
||||
public final static @org.jetbrains.annotations.NotNull method customIntArrayOf(@org.jetbrains.annotations.NotNull p0: int[]): int[]
|
||||
public final static @org.jetbrains.annotations.NotNull method customLongArrayOf(@org.jetbrains.annotations.NotNull p0: long[]): long[]
|
||||
public final static @org.jetbrains.annotations.NotNull method customShortArrayOf(@org.jetbrains.annotations.NotNull p0: short[]): short[]
|
||||
public final static method eqBoolean(@org.jetbrains.annotations.NotNull p0: boolean[], @org.jetbrains.annotations.NotNull p1: boolean[]): boolean
|
||||
public final static method eqByte(@org.jetbrains.annotations.NotNull p0: byte[], @org.jetbrains.annotations.NotNull p1: byte[]): boolean
|
||||
public final static method eqChar(@org.jetbrains.annotations.NotNull p0: char[], @org.jetbrains.annotations.NotNull p1: char[]): boolean
|
||||
public final static method eqDouble(@org.jetbrains.annotations.NotNull p0: double[], @org.jetbrains.annotations.NotNull p1: double[]): boolean
|
||||
public final static method eqFloat(@org.jetbrains.annotations.NotNull p0: float[], @org.jetbrains.annotations.NotNull p1: float[]): boolean
|
||||
public final static method eqInt(@org.jetbrains.annotations.NotNull p0: int[], @org.jetbrains.annotations.NotNull p1: int[]): boolean
|
||||
public final static method eqLong(@org.jetbrains.annotations.NotNull p0: long[], @org.jetbrains.annotations.NotNull p1: long[]): boolean
|
||||
public final static method eqShort(@org.jetbrains.annotations.NotNull p0: short[], @org.jetbrains.annotations.NotNull p1: short[]): boolean
|
||||
}
|
||||
+6
@@ -611,6 +611,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
|
||||
doTest(fileName);
|
||||
}
|
||||
|
||||
@TestMetadata("primitiveArrays.kt")
|
||||
public void testPrimitiveArrays() throws Exception {
|
||||
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/arrays/primitiveArrays.kt");
|
||||
doTest(fileName);
|
||||
}
|
||||
|
||||
@TestMetadata("stdlib.kt")
|
||||
public void testStdlib() throws Exception {
|
||||
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/arrays/stdlib.kt");
|
||||
|
||||
@@ -611,6 +611,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
|
||||
doTest(fileName);
|
||||
}
|
||||
|
||||
@TestMetadata("primitiveArrays.kt")
|
||||
public void testPrimitiveArrays() throws Exception {
|
||||
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/arrays/primitiveArrays.kt");
|
||||
doTest(fileName);
|
||||
}
|
||||
|
||||
@TestMetadata("stdlib.kt")
|
||||
public void testStdlib() throws Exception {
|
||||
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/arrays/stdlib.kt");
|
||||
|
||||
@@ -611,6 +611,12 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
|
||||
doTest(fileName);
|
||||
}
|
||||
|
||||
@TestMetadata("primitiveArrays.kt")
|
||||
public void testPrimitiveArrays() throws Exception {
|
||||
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/arrays/primitiveArrays.kt");
|
||||
doTest(fileName);
|
||||
}
|
||||
|
||||
@TestMetadata("stdlib.kt")
|
||||
public void testStdlib() throws Exception {
|
||||
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/arrays/stdlib.kt");
|
||||
|
||||
Reference in New Issue
Block a user