diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 7de2e186ad6..46c0f426584 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -25,8 +25,8 @@ import com.intellij.util.ArrayUtil; import com.intellij.util.Function; import com.intellij.util.containers.Stack; import kotlin.Pair; -import kotlin.collections.CollectionsKt; import kotlin.Unit; +import kotlin.collections.CollectionsKt; import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -56,6 +56,8 @@ import org.jetbrains.kotlin.jvm.bindingContextSlices.BindingContextSlicesKt; import org.jetbrains.kotlin.lexer.KtTokens; import org.jetbrains.kotlin.load.java.JvmAbi; import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor; +import org.jetbrains.kotlin.name.ClassId; +import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.BindingContext; @@ -78,11 +80,13 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature; import org.jetbrains.kotlin.resolve.scopes.receivers.*; +import org.jetbrains.kotlin.serialization.deserialization.FindClassInModuleKt; import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor; import org.jetbrains.kotlin.types.KotlinType; import org.jetbrains.kotlin.types.TypeProjection; import org.jetbrains.kotlin.types.TypeUtils; import org.jetbrains.kotlin.types.checker.KotlinTypeChecker; +import org.jetbrains.kotlin.utils.StringsKt; import org.jetbrains.org.objectweb.asm.Label; import org.jetbrains.org.objectweb.asm.MethodVisitor; import org.jetbrains.org.objectweb.asm.Opcodes; @@ -97,8 +101,7 @@ import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.*; import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.*; import static org.jetbrains.kotlin.resolve.BindingContext.*; import static org.jetbrains.kotlin.resolve.BindingContextUtils.*; -import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry; -import static org.jetbrains.kotlin.resolve.DescriptorUtils.isObject; +import static org.jetbrains.kotlin.resolve.DescriptorUtils.*; import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*; import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionExpression; import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionLiteral; @@ -3345,7 +3348,7 @@ public class ExpressionCodegen extends KtVisitor impleme Type type = expressionType(expression); if (type.getSort() == Type.ARRAY) { //noinspection ConstantConditions - return generateNewArray(expression, bindingContext.getType(expression)); + return generateNewArray(expression, bindingContext.getType(expression), resolvedCall); } return generateConstructorCall(resolvedCall, type); @@ -3391,20 +3394,54 @@ public class ExpressionCodegen extends KtVisitor impleme }); } - public StackValue generateNewArray(@NotNull KtCallExpression expression, @NotNull final KotlinType arrayType) { - assert expression.getValueArguments().size() == 1 : "Size argument expected"; + public StackValue generateNewArray( + @NotNull KtCallExpression expression, @NotNull final KotlinType arrayType, @NotNull ResolvedCall resolvedCall + ) { + List args = expression.getValueArguments(); + assert args.size() == 1 || args.size() == 2 : "Unknown constructor called: " + args.size() + " arguments"; - final KtExpression sizeExpression = expression.getValueArguments().get(0).getArgumentExpression(); - Type type = typeMapper.mapType(arrayType); + if (args.size() == 1) { + final KtExpression sizeExpression = args.get(0).getArgumentExpression(); + return StackValue.operation(typeMapper.mapType(arrayType), new Function1() { + @Override + public Unit invoke(InstructionAdapter v) { + gen(sizeExpression, Type.INT_TYPE); + newArrayInstruction(arrayType); + return Unit.INSTANCE; + } + }); + } - return StackValue.operation(type, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - gen(sizeExpression, Type.INT_TYPE); - newArrayInstruction(arrayType); - return Unit.INSTANCE; + final ConstructorDescriptor constructor = (ConstructorDescriptor) resolvedCall.getResultingDescriptor(); + + final ClassDescriptor intrinsicConstructors = + FindClassInModuleKt.findClassAcrossModuleDependencies( + getContainingModule(context.getContextDescriptor()), + ClassId.topLevel(new FqName("kotlin.jvm.internal.IntrinsicArrayConstructors")) + ); + // TODO: do not depend on a class from the runtime + assert intrinsicConstructors != null : "Class IntrinsicArrayConstructors is not found"; + + ResolvedCall fakeResolvedCall = new DelegatingResolvedCall(resolvedCall) { + private final CallableDescriptor descriptor; + + { + Collection functions = intrinsicConstructors.getUnsubstitutedMemberScope().getContributedFunctions( + constructor.getContainingDeclaration().getName(), NoLookupLocation.FROM_BACKEND); + assert functions.size() == 1 + : "IntrinsicArrayConstructors does not have a single constructor for " + + constructor.getContainingDeclaration().getName() + ":\n" + StringsKt.join(functions, "\n"); + descriptor = CollectionsKt.single(functions); } - }); + + @NotNull + @Override + public CallableDescriptor getResultingDescriptor() { + return descriptor; + } + }; + + return invokeFunction(fakeResolvedCall, StackValue.singleton(intrinsicConstructors, typeMapper)); } public void newArrayInstruction(@NotNull KotlinType arrayType) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java index f50ae6233f4..58b11fe2106 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java @@ -110,7 +110,7 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat if (referencedFunction instanceof ConstructorDescriptor) { if (returnType.getSort() == Type.ARRAY) { //noinspection ConstantConditions - result = codegen.generateNewArray(fakeExpression, referencedFunction.getReturnType()); + result = codegen.generateNewArray(fakeExpression, referencedFunction.getReturnType(), fakeResolvedCall); } else { result = codegen.generateConstructorCall(fakeResolvedCall, returnType); diff --git a/core/builtins/native/kotlin/Arrays.kt b/core/builtins/native/kotlin/Arrays.kt index 416ecc2831b..38e5c160637 100644 --- a/core/builtins/native/kotlin/Arrays.kt +++ b/core/builtins/native/kotlin/Arrays.kt @@ -23,6 +23,12 @@ package kotlin * @constructor Creates a new array of the specified [size], with all elements initialized to zero. */ public class ByteArray(size: Int) : Cloneable { + /** + * Creates a new array of the specified [size], where each element is calculated by calling the specified + * [init] function. The [init] function returns an array element given its index. + */ + public constructor(size: Int, init: (Int) -> Byte) + /** Returns the array element at the given [index]. This method can be called using the index operator. */ public operator fun get(index: Int): Byte /** Sets the element at the given [index] to the given [value]. This method can be called using the index operator. */ @@ -42,6 +48,12 @@ public class ByteArray(size: Int) : Cloneable { * @constructor Creates a new array of the specified [size], with all elements initialized to zero. */ public class CharArray(size: Int) : Cloneable { + /** + * Creates a new array of the specified [size], where each element is calculated by calling the specified + * [init] function. The [init] function returns an array element given its index. + */ + public constructor(size: Int, init: (Int) -> Char) + /** Returns the array element at the given [index]. This method can be called using the index operator. */ public operator fun get(index: Int): Char /** Sets the element at the given [index] to the given [value]. This method can be called using the index operator. */ @@ -61,6 +73,12 @@ public class CharArray(size: Int) : Cloneable { * @constructor Creates a new array of the specified [size], with all elements initialized to zero. */ public class ShortArray(size: Int) : Cloneable { + /** + * Creates a new array of the specified [size], where each element is calculated by calling the specified + * [init] function. The [init] function returns an array element given its index. + */ + public constructor(size: Int, init: (Int) -> Short) + /** Returns the array element at the given [index]. This method can be called using the index operator. */ public operator fun get(index: Int): Short /** Sets the element at the given [index] to the given [value]. This method can be called using the index operator. */ @@ -80,6 +98,12 @@ public class ShortArray(size: Int) : Cloneable { * @constructor Creates a new array of the specified [size], with all elements initialized to zero. */ public class IntArray(size: Int) : Cloneable { + /** + * Creates a new array of the specified [size], where each element is calculated by calling the specified + * [init] function. The [init] function returns an array element given its index. + */ + public constructor(size: Int, init: (Int) -> Int) + /** Returns the array element at the given [index]. This method can be called using the index operator. */ public operator fun get(index: Int): Int /** Sets the element at the given [index] to the given [value]. This method can be called using the index operator. */ @@ -99,6 +123,12 @@ public class IntArray(size: Int) : Cloneable { * @constructor Creates a new array of the specified [size], with all elements initialized to zero. */ public class LongArray(size: Int) : Cloneable { + /** + * Creates a new array of the specified [size], where each element is calculated by calling the specified + * [init] function. The [init] function returns an array element given its index. + */ + public constructor(size: Int, init: (Int) -> Long) + /** Returns the array element at the given [index]. This method can be called using the index operator. */ public operator fun get(index: Int): Long /** Sets the element at the given [index] to the given [value]. This method can be called using the index operator. */ @@ -118,6 +148,12 @@ public class LongArray(size: Int) : Cloneable { * @constructor Creates a new array of the specified [size], with all elements initialized to zero. */ public class FloatArray(size: Int) : Cloneable { + /** + * Creates a new array of the specified [size], where each element is calculated by calling the specified + * [init] function. The [init] function returns an array element given its index. + */ + public constructor(size: Int, init: (Int) -> Float) + /** Returns the array element at the given [index]. This method can be called using the index operator. */ public operator fun get(index: Int): Float /** Sets the element at the given [index] to the given [value]. This method can be called using the index operator. */ @@ -137,6 +173,12 @@ public class FloatArray(size: Int) : Cloneable { * @constructor Creates a new array of the specified [size], with all elements initialized to zero. */ public class DoubleArray(size: Int) : Cloneable { + /** + * Creates a new array of the specified [size], where each element is calculated by calling the specified + * [init] function. The [init] function returns an array element given its index. + */ + public constructor(size: Int, init: (Int) -> Double) + /** Returns the array element at the given [index]. This method can be called using the index operator. */ public operator fun get(index: Int): Double /** Sets the element at the given [index] to the given [value]. This method can be called using the index operator. */ @@ -156,6 +198,12 @@ public class DoubleArray(size: Int) : Cloneable { * @constructor Creates a new array of the specified [size], with all elements initialized to false. */ public class BooleanArray(size: Int) : Cloneable { + /** + * Creates a new array of the specified [size], where each element is calculated by calling the specified + * [init] function. The [init] function returns an array element given its index. + */ + public constructor(size: Int, init: (Int) -> Boolean) + /** Returns the array element at the given [index]. This method can be called using the index operator. */ public operator fun get(index: Int): Boolean /** Sets the element at the given [index] to the given [value]. This method can be called using the index operator. */ diff --git a/core/builtins/src/kotlin/ArrayIntrinsics.kt b/core/builtins/src/kotlin/ArrayIntrinsics.kt index 0d21ccff3da..f1df2409803 100644 --- a/core/builtins/src/kotlin/ArrayIntrinsics.kt +++ b/core/builtins/src/kotlin/ArrayIntrinsics.kt @@ -29,102 +29,6 @@ public inline fun Array(size: Int, init: (Int) -> T): return result as Array } -/** - * Returns an array of [Double] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun DoubleArray(size: Int, init: (Int) -> Double): DoubleArray { - val result = DoubleArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Float] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun FloatArray(size: Int, init: (Int) -> Float): FloatArray { - val result = FloatArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Long] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun LongArray(size: Int, init: (Int) -> Long): LongArray { - val result = LongArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Int] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun IntArray(size: Int, init: (Int) -> Int): IntArray { - val result = IntArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Char] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun CharArray(size: Int, init: (Int) -> Char): CharArray { - val result = CharArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Short] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun ShortArray(size: Int, init: (Int) -> Short): ShortArray { - val result = ShortArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Byte] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun ByteArray(size: Int, init: (Int) -> Byte): ByteArray { - val result = ByteArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Boolean] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun BooleanArray(size: Int, init: (Int) -> Boolean): BooleanArray { - val result = BooleanArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - /** * Returns an empty array of the specified type [T]. */ diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/IntrinsicArrayConstructors.kt b/core/runtime.jvm/src/kotlin/jvm/internal/IntrinsicArrayConstructors.kt new file mode 100644 index 00000000000..105d068bece --- /dev/null +++ b/core/runtime.jvm/src/kotlin/jvm/internal/IntrinsicArrayConstructors.kt @@ -0,0 +1,84 @@ +/* + * Copyright 2010-2016 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package kotlin.jvm.internal + +@Suppress("unused") +object IntrinsicArrayConstructors { + private inline fun DoubleArray(size: Int, init: (Int) -> Double): DoubleArray { + val result = DoubleArray(size) + for (i in 0..size - 1) { + result[i] = init(i) + } + return result + } + + private inline fun FloatArray(size: Int, init: (Int) -> Float): FloatArray { + val result = FloatArray(size) + for (i in 0..size - 1) { + result[i] = init(i) + } + return result + } + + private inline fun LongArray(size: Int, init: (Int) -> Long): LongArray { + val result = LongArray(size) + for (i in 0..size - 1) { + result[i] = init(i) + } + return result + } + + private inline fun IntArray(size: Int, init: (Int) -> Int): IntArray { + val result = IntArray(size) + for (i in 0..size - 1) { + result[i] = init(i) + } + return result + } + + private inline fun CharArray(size: Int, init: (Int) -> Char): CharArray { + val result = CharArray(size) + for (i in 0..size - 1) { + result[i] = init(i) + } + return result + } + + private inline fun ShortArray(size: Int, init: (Int) -> Short): ShortArray { + val result = ShortArray(size) + for (i in 0..size - 1) { + result[i] = init(i) + } + return result + } + + private inline fun ByteArray(size: Int, init: (Int) -> Byte): ByteArray { + val result = ByteArray(size) + for (i in 0..size - 1) { + result[i] = init(i) + } + return result + } + + private inline fun BooleanArray(size: Int, init: (Int) -> Boolean): BooleanArray { + val result = BooleanArray(size) + for (i in 0..size - 1) { + result[i] = init(i) + } + return result + } +} diff --git a/generators/src/org/jetbrains/kotlin/generators/builtins/arrays.kt b/generators/src/org/jetbrains/kotlin/generators/builtins/arrays.kt index 32ef864c4a3..a84a905c29a 100644 --- a/generators/src/org/jetbrains/kotlin/generators/builtins/arrays.kt +++ b/generators/src/org/jetbrains/kotlin/generators/builtins/arrays.kt @@ -17,7 +17,7 @@ package org.jetbrains.kotlin.generators.builtins.arrays import org.jetbrains.kotlin.generators.builtins.PrimitiveType -import org.jetbrains.kotlin.generators.builtins.generateBuiltIns.* +import org.jetbrains.kotlin.generators.builtins.generateBuiltIns.BuiltInsSourceGenerator import java.io.PrintWriter class GenerateArrays(out: PrintWriter) : BuiltInsSourceGenerator(out) { @@ -27,12 +27,18 @@ class GenerateArrays(out: PrintWriter) : BuiltInsSourceGenerator(out) { for (kind in PrimitiveType.values()) { val typeLower = kind.name.toLowerCase() val s = kind.capitalized - val defaultValue = when(kind) { PrimitiveType.BOOLEAN -> "false"; else -> "zero" } + val defaultValue = if (kind == PrimitiveType.BOOLEAN) "false" else "zero" out.println("/**") - out.println(" * An array of ${typeLower}s. When targeting the JVM, instances of this class are represented as `${typeLower}[]`.") - out.println(" * @constructor Creates a new array of the specified [size], with all elements initialized to ${defaultValue}.") + out.println(" * An array of ${typeLower}s. When targeting the JVM, instances of this class are represented as `$typeLower[]`.") + out.println(" * @constructor Creates a new array of the specified [size], with all elements initialized to $defaultValue.") out.println(" */") out.println("public class ${s}Array(size: Int) : Cloneable {") + out.println(" /**") + out.println(" * Creates a new array of the specified [size], where each element is calculated by calling the specified") + out.println(" * [init] function. The [init] function returns an array element given its index.") + out.println(" */") + out.println(" public constructor(size: Int, init: (Int) -> $s)") + out.println() out.println(" /** Returns the array element at the given [index]. This method can be called using the index operator. */") out.println(" public operator fun get(index: Int): $s") out.println(" /** Sets the element at the given [index] to the given [value]. This method can be called using the index operator. */") diff --git a/js/js.libraries/src/core/kotlin.kt b/js/js.libraries/src/core/kotlin.kt index de32e8b8baf..8118a5d2a3c 100644 --- a/js/js.libraries/src/core/kotlin.kt +++ b/js/js.libraries/src/core/kotlin.kt @@ -14,133 +14,34 @@ public inline fun Array(size: Int, init: (Int) -> T): Array { return result as Array } -/** - * Returns an array of [Double] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun DoubleArray(size: Int, init: (Int) -> Double): DoubleArray { - val result = DoubleArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Float] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun FloatArray(size: Int, init: (Int) -> Float): FloatArray { - val result = FloatArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Long] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun LongArray(size: Int, init: (Int) -> Long): LongArray { - val result = LongArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Int] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun IntArray(size: Int, init: (Int) -> Int): IntArray { - val result = IntArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Char] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun CharArray(size: Int, init: (Int) -> Char): CharArray { - val result = CharArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Short] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun ShortArray(size: Int, init: (Int) -> Short): ShortArray { - val result = ShortArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Byte] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun ByteArray(size: Int, init: (Int) -> Byte): ByteArray { - val result = ByteArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - -/** - * Returns an array of [Boolean] numbers with the specified [size], - * where each element is calculated by calling the specified - * [init] function. The `init` function returns an array element given its index. - */ -public inline fun BooleanArray(size: Int, init: (Int) -> Boolean): BooleanArray { - val result = BooleanArray(size) - for (i in 0..size - 1) - result[i] = init(i) - return result -} - /** * Returns an empty array of the specified type [T]. */ public inline fun emptyArray(): Array = arrayOfNulls(0) as Array - @library public fun arrayOf(vararg elements: T): Array = noImpl -// "constructors" for primitive types array +@library +public fun doubleArrayOf(vararg elements: Double): DoubleArray = noImpl @library -public fun doubleArrayOf(vararg elements: Double): DoubleArray = noImpl +public fun floatArrayOf(vararg elements: Float): FloatArray = noImpl @library -public fun floatArrayOf(vararg elements: Float): FloatArray = noImpl +public fun longArrayOf(vararg elements: Long): LongArray = noImpl @library -public fun longArrayOf(vararg elements: Long): LongArray = noImpl +public fun intArrayOf(vararg elements: Int): IntArray = noImpl @library -public fun intArrayOf(vararg elements: Int): IntArray = noImpl +public fun charArrayOf(vararg elements: Char): CharArray = noImpl @library -public fun charArrayOf(vararg elements: Char): CharArray = noImpl +public fun shortArrayOf(vararg elements: Short): ShortArray = noImpl @library -public fun shortArrayOf(vararg elements: Short): ShortArray = noImpl - -@library -public fun byteArrayOf(vararg elements: Byte): ByteArray = noImpl +public fun byteArrayOf(vararg elements: Byte): ByteArray = noImpl @library public fun booleanArrayOf(vararg elements: Boolean): BooleanArray = noImpl