From 9babd90999d137302b884404c4aa53b5eff076c4 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 23 Aug 2017 16:42:23 +0300 Subject: [PATCH] Support default arguments and varargs for callable references #KT-8834 #KT-19869 #KT-25514 --- .../FunctionReferenceGenerationStrategy.java | 49 +++++++++++---- .../calls/model/VarargValueArgument.java | 12 +++- .../varargAndDefaults/boundReferences.kt | 47 ++++++++++++++ .../varargAndDefaults/defaultAfterVararg.kt | 11 ++++ .../defaultWithGenericExpectedType.kt | 10 +++ .../emptyVarargAndDefault.kt | 11 ++++ .../varargAndDefaults/inline.kt | 9 +++ .../manyDefaultsAndVararg.kt | 28 +++++++++ .../simpleDefaultArgument.kt | 10 +++ .../varargAndDefaults/simpleEmptyVararg.kt | 11 ++++ .../varargAndDefaults/varargViewedAsArray.kt | 10 +++ .../varargWithDefaultValue.kt | 13 ++++ .../ir/IrBlackBoxCodegenTestGenerated.java | 63 +++++++++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 63 +++++++++++++++++++ .../LightAnalysisModeTestGenerated.java | 63 +++++++++++++++++++ .../IrJsCodegenBoxTestGenerated.java | 63 +++++++++++++++++++ .../semantics/JsCodegenBoxTestGenerated.java | 63 +++++++++++++++++++ 17 files changed, 523 insertions(+), 13 deletions(-) create mode 100644 compiler/testData/codegen/box/callableReference/varargAndDefaults/boundReferences.kt create mode 100644 compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultAfterVararg.kt create mode 100644 compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultWithGenericExpectedType.kt create mode 100644 compiler/testData/codegen/box/callableReference/varargAndDefaults/emptyVarargAndDefault.kt create mode 100644 compiler/testData/codegen/box/callableReference/varargAndDefaults/inline.kt create mode 100644 compiler/testData/codegen/box/callableReference/varargAndDefaults/manyDefaultsAndVararg.kt create mode 100644 compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleDefaultArgument.kt create mode 100644 compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleEmptyVararg.kt create mode 100644 compiler/testData/codegen/box/callableReference/varargAndDefaults/varargViewedAsArray.kt create mode 100644 compiler/testData/codegen/box/callableReference/varargAndDefaults/varargWithDefaultValue.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java index 39c287fabda..a834c3bfb31 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionReferenceGenerationStrategy.java @@ -14,10 +14,8 @@ import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.BindingContext; -import org.jetbrains.kotlin.resolve.calls.model.DelegatingResolvedCall; -import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument; -import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; -import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument; +import org.jetbrains.kotlin.resolve.calls.components.ArgumentsUtilsKt; +import org.jetbrains.kotlin.resolve.calls.model.*; import org.jetbrains.kotlin.resolve.calls.util.CallMaker; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature; import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver; @@ -94,8 +92,8 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat */ int receivers = CallableReferenceUtilKt.computeExpectedNumberOfReceivers(referencedFunction, receiverType != null); - KtCallExpression fakeExpression = - CodegenUtil.constructFakeFunctionCall(state.getProject(), functionDescriptor.getValueParameters().size() - receivers); + int fakeArgCount = functionDescriptor.getValueParameters().size() - receivers; + KtCallExpression fakeExpression = CodegenUtil.constructFakeFunctionCall(state.getProject(), fakeArgCount); List fakeArguments = fakeExpression.getValueArguments(); ReceiverValue dispatchReceiver = computeAndSaveReceiver(signature, codegen, referencedFunction.getDispatchReceiverParameter()); @@ -106,11 +104,40 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat private final Map argumentMap = new LinkedHashMap<>(); { - int index = 0; - List parameters = referencedFunction.getValueParameters(); - for (ValueArgument argument : fakeArguments) { - argumentMap.put(parameters.get(index), new ExpressionValueArgument(argument)); - index++; + int i = 0; + + for (ValueParameterDescriptor parameter : referencedFunction.getValueParameters()) { + if (parameter.getVarargElementType() != null) { + // Two cases are possible for a function reference with a vararg parameter of type T: either several arguments + // of type T are bound to that parameter, or one argument of type Array. In the former case the argument + // is bound as a VarargValueArgument, in the latter it's an ExpressionValueArgument + + if (i == fakeArgCount) { + // If we've exhausted the argument list of the reference and we still have one vararg parameter left, + // we should use its default value if present, or simply an empty vararg instead + argumentMap.put( + parameter, + ArgumentsUtilsKt.hasDefaultValue(parameter) ? DefaultValueArgument.DEFAULT : new VarargValueArgument() + ); + continue; + } + + if (functionDescriptor.getValueParameters().get(receivers + i).getType().equals(parameter.getVarargElementType())) { + argumentMap.put(parameter, new VarargValueArgument(fakeArguments.subList(i, fakeArgCount))); + i = fakeArgCount; + continue; + } + } + + if (i < fakeArgCount) { + argumentMap.put(parameter, new ExpressionValueArgument(fakeArguments.get(i++))); + } + else { + assert ArgumentsUtilsKt.hasDefaultValue(parameter) : + "Parameter should be either vararg or expression or default: " + parameter + + " (reference in: " + functionDescriptor.getContainingDeclaration() + ")"; + argumentMap.put(parameter, DefaultValueArgument.DEFAULT); + } } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/VarargValueArgument.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/VarargValueArgument.java index f733d82ce8a..5860d1caaa0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/VarargValueArgument.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/model/VarargValueArgument.java @@ -16,16 +16,24 @@ package org.jetbrains.kotlin.resolve.calls.model; -import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.psi.KtExpression; import org.jetbrains.kotlin.psi.ValueArgument; +import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class VarargValueArgument implements ResolvedValueArgument { - private final List arguments = Lists.newArrayList(); + private final List arguments; + + public VarargValueArgument() { + this.arguments = new ArrayList<>(); + } + + public VarargValueArgument(@NotNull List arguments) { + this.arguments = new ArrayList<>(arguments); + } public void addArgument(@NotNull ValueArgument argument) { arguments.add(argument); diff --git a/compiler/testData/codegen/box/callableReference/varargAndDefaults/boundReferences.kt b/compiler/testData/codegen/box/callableReference/varargAndDefaults/boundReferences.kt new file mode 100644 index 00000000000..9f483586044 --- /dev/null +++ b/compiler/testData/codegen/box/callableReference/varargAndDefaults/boundReferences.kt @@ -0,0 +1,47 @@ +// !LANGUAGE: +NewInference +// IGNORE_BACKEND: JS, JS_IR, JVM_IR +// WITH_RUNTIME + +import kotlin.test.assertEquals + +class C(val expected: Int) { + fun memberVararg(i: Int, vararg s: String) { + assertEquals(expected, i) + assertEquals(0, s.size) + } + + fun memberDefault(i: Int, s: String = "") { + assertEquals(expected, i) + assertEquals("", s) + } + + fun memberBoth(i: Int, s: String = "", vararg t: String) { + assertEquals(expected, i) + assertEquals("", s) + assertEquals(0, t.size) + } +} + +fun C.extensionVararg(i: Int, vararg s: String) { + memberVararg(i, *s) +} + +fun C.extensionDefault(i: Int, s: String = "") { + memberDefault(i, s) +} + +fun C.extensionBoth(i: Int, s: String = "", vararg t: String) { + memberBoth(i, s, *t) +} + +fun test(f: (Int) -> Unit, p: Int) = f(p) + +fun box(): String { + test(C(42)::memberVararg, 42) + test(C(42)::memberDefault, 42) + test(C(42)::memberBoth, 42) + test(C(42)::extensionVararg, 42) + test(C(42)::extensionDefault, 42) + test(C(42)::extensionBoth, 42) + return "OK" +} diff --git a/compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultAfterVararg.kt b/compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultAfterVararg.kt new file mode 100644 index 00000000000..4e1f542f7be --- /dev/null +++ b/compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultAfterVararg.kt @@ -0,0 +1,11 @@ +// !LANGUAGE: +NewInference +// IGNORE_BACKEND: JS, JS_IR, JVM_IR + +fun foo(vararg a: String, result: String = "OK"): String = + if (a.size == 0) result else "Fail" + +fun call(f: () -> String): String = f() + +fun box(): String { + return call(::foo) +} diff --git a/compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultWithGenericExpectedType.kt b/compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultWithGenericExpectedType.kt new file mode 100644 index 00000000000..a65613c794f --- /dev/null +++ b/compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultWithGenericExpectedType.kt @@ -0,0 +1,10 @@ +// !LANGUAGE: +NewInference +// IGNORE_BACKEND: JS_IR, JVM_IR + +fun foo(x: String, y: Char = 'K'): String = x + y + +fun call(f: (T) -> U, x: T): U = f(x) + +fun box(): String { + return call(::foo, "O") +} diff --git a/compiler/testData/codegen/box/callableReference/varargAndDefaults/emptyVarargAndDefault.kt b/compiler/testData/codegen/box/callableReference/varargAndDefaults/emptyVarargAndDefault.kt new file mode 100644 index 00000000000..acb60f3a5c1 --- /dev/null +++ b/compiler/testData/codegen/box/callableReference/varargAndDefaults/emptyVarargAndDefault.kt @@ -0,0 +1,11 @@ +// !LANGUAGE: +NewInference +// IGNORE_BACKEND: JS, JS_IR, JVM_IR + +fun foo(x: String = "O", vararg y: String): String = + if (y.size == 0) x + "K" else "Fail" + +fun call(f: () -> String): String = f() + +fun box(): String { + return call(::foo) +} diff --git a/compiler/testData/codegen/box/callableReference/varargAndDefaults/inline.kt b/compiler/testData/codegen/box/callableReference/varargAndDefaults/inline.kt new file mode 100644 index 00000000000..46fc008abd5 --- /dev/null +++ b/compiler/testData/codegen/box/callableReference/varargAndDefaults/inline.kt @@ -0,0 +1,9 @@ +// !LANGUAGE: +NewInference +// IGNORE_BACKEND: JS, JS_IR, JVM_IR + +fun foo(vararg l: Long, s: String = "OK"): String = + if (l.size == 0) s else "Fail" + +inline fun bar(f: () -> String): String = f() + +fun box(): String = bar(::foo) diff --git a/compiler/testData/codegen/box/callableReference/varargAndDefaults/manyDefaultsAndVararg.kt b/compiler/testData/codegen/box/callableReference/varargAndDefaults/manyDefaultsAndVararg.kt new file mode 100644 index 00000000000..ba967d5a958 --- /dev/null +++ b/compiler/testData/codegen/box/callableReference/varargAndDefaults/manyDefaultsAndVararg.kt @@ -0,0 +1,28 @@ +// !LANGUAGE: +NewInference +// IGNORE_BACKEND: JS, JS_IR, JVM_IR +// WITH_RUNTIME + +import kotlin.test.assertEquals + +object E : Exception() + +fun foo( + a: String = "fail", + b: Int, + c: Double = 3.14, + vararg d: String, + e: Throwable = E +) { + assertEquals("ok", a) + assertEquals(42, b) + assertEquals(3.14, c) + assertEquals(0, d.size) + assertEquals(E, e) +} + +fun bar(f: (String, Int) -> Unit) = f("ok", 42) + +fun box(): String { + bar(::foo) + return "OK" +} diff --git a/compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleDefaultArgument.kt b/compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleDefaultArgument.kt new file mode 100644 index 00000000000..5e57cac4ba0 --- /dev/null +++ b/compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleDefaultArgument.kt @@ -0,0 +1,10 @@ +// !LANGUAGE: +NewInference +// IGNORE_BACKEND: JS_IR, JVM_IR + +fun foo(x: String, y: String = "K"): String = x + y + +fun call(f: (String) -> String, x: String): String = f(x) + +fun box(): String { + return call(::foo, "O") +} diff --git a/compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleEmptyVararg.kt b/compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleEmptyVararg.kt new file mode 100644 index 00000000000..7edf5673c09 --- /dev/null +++ b/compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleEmptyVararg.kt @@ -0,0 +1,11 @@ +// !LANGUAGE: +NewInference +// IGNORE_BACKEND: JS, JS_IR, JVM_IR + +fun foo(x: String, vararg y: String): String = + if (y.size == 0) x + "K" else "Fail" + +fun call(f: (String) -> String, x: String): String = f(x) + +fun box(): String { + return call(::foo, "O") +} diff --git a/compiler/testData/codegen/box/callableReference/varargAndDefaults/varargViewedAsArray.kt b/compiler/testData/codegen/box/callableReference/varargAndDefaults/varargViewedAsArray.kt new file mode 100644 index 00000000000..dd859458ab6 --- /dev/null +++ b/compiler/testData/codegen/box/callableReference/varargAndDefaults/varargViewedAsArray.kt @@ -0,0 +1,10 @@ +// KT-25514 Support usage of function reference with vararg where function of array is expected in new inference +// IGNORE_BACKEND: JVM_IR, JS_IR + +fun foo(x: Int, vararg y: String): String = y[0] + +fun useArray(f: (Int, Array) -> String): String = f(1, Array(1) { "OK" }) + +fun box(): String { + return useArray(::foo) +} diff --git a/compiler/testData/codegen/box/callableReference/varargAndDefaults/varargWithDefaultValue.kt b/compiler/testData/codegen/box/callableReference/varargAndDefaults/varargWithDefaultValue.kt new file mode 100644 index 00000000000..38c8a548777 --- /dev/null +++ b/compiler/testData/codegen/box/callableReference/varargAndDefaults/varargWithDefaultValue.kt @@ -0,0 +1,13 @@ +// !LANGUAGE: +NewInference +// IGNORE_BACKEND: JS, JS_IR, JVM_IR + +fun foo(x: Int, vararg y: String = arrayOf("Aaa")): String = + if (y[0].length == x) "OK" else "Fail" + +fun use0(f: (Int) -> String): String = f(3) +fun use1(f: (Int, String) -> String): String = f(5, "Bbbbb") + +fun box(): String { + if (use0(::foo) != "OK") return "Fail" + return use1(::foo) +} diff --git a/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 3df792b7192..a68bd55ebea 100644 --- a/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -2335,6 +2335,69 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/callableReference/serializability/withReflect.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/callableReference/varargAndDefaults") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class VarargAndDefaults extends AbstractIrBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInVarargAndDefaults() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/callableReference/varargAndDefaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true); + } + + @TestMetadata("boundReferences.kt") + public void testBoundReferences() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/boundReferences.kt"); + } + + @TestMetadata("defaultAfterVararg.kt") + public void testDefaultAfterVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultAfterVararg.kt"); + } + + @TestMetadata("defaultWithGenericExpectedType.kt") + public void testDefaultWithGenericExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultWithGenericExpectedType.kt"); + } + + @TestMetadata("emptyVarargAndDefault.kt") + public void testEmptyVarargAndDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/emptyVarargAndDefault.kt"); + } + + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/inline.kt"); + } + + @TestMetadata("manyDefaultsAndVararg.kt") + public void testManyDefaultsAndVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/manyDefaultsAndVararg.kt"); + } + + @TestMetadata("simpleDefaultArgument.kt") + public void testSimpleDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleDefaultArgument.kt"); + } + + @TestMetadata("simpleEmptyVararg.kt") + public void testSimpleEmptyVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleEmptyVararg.kt"); + } + + @TestMetadata("varargViewedAsArray.kt") + public void testVarargViewedAsArray() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/varargViewedAsArray.kt"); + } + + @TestMetadata("varargWithDefaultValue.kt") + public void testVarargWithDefaultValue() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/varargWithDefaultValue.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/casts") diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 90abef0e139..cd677a37b9f 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -2335,6 +2335,69 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/callableReference/serializability/withReflect.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/callableReference/varargAndDefaults") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class VarargAndDefaults extends AbstractBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInVarargAndDefaults() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/callableReference/varargAndDefaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true); + } + + @TestMetadata("boundReferences.kt") + public void testBoundReferences() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/boundReferences.kt"); + } + + @TestMetadata("defaultAfterVararg.kt") + public void testDefaultAfterVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultAfterVararg.kt"); + } + + @TestMetadata("defaultWithGenericExpectedType.kt") + public void testDefaultWithGenericExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultWithGenericExpectedType.kt"); + } + + @TestMetadata("emptyVarargAndDefault.kt") + public void testEmptyVarargAndDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/emptyVarargAndDefault.kt"); + } + + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/inline.kt"); + } + + @TestMetadata("manyDefaultsAndVararg.kt") + public void testManyDefaultsAndVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/manyDefaultsAndVararg.kt"); + } + + @TestMetadata("simpleDefaultArgument.kt") + public void testSimpleDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleDefaultArgument.kt"); + } + + @TestMetadata("simpleEmptyVararg.kt") + public void testSimpleEmptyVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleEmptyVararg.kt"); + } + + @TestMetadata("varargViewedAsArray.kt") + public void testVarargViewedAsArray() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/varargViewedAsArray.kt"); + } + + @TestMetadata("varargWithDefaultValue.kt") + public void testVarargWithDefaultValue() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/varargWithDefaultValue.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/casts") diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index d9bf5259028..dd9961b7220 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -2335,6 +2335,69 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/callableReference/serializability/withReflect.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/callableReference/varargAndDefaults") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class VarargAndDefaults extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInVarargAndDefaults() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/callableReference/varargAndDefaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true); + } + + @TestMetadata("boundReferences.kt") + public void testBoundReferences() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/boundReferences.kt"); + } + + @TestMetadata("defaultAfterVararg.kt") + public void testDefaultAfterVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultAfterVararg.kt"); + } + + @TestMetadata("defaultWithGenericExpectedType.kt") + public void testDefaultWithGenericExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultWithGenericExpectedType.kt"); + } + + @TestMetadata("emptyVarargAndDefault.kt") + public void testEmptyVarargAndDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/emptyVarargAndDefault.kt"); + } + + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/inline.kt"); + } + + @TestMetadata("manyDefaultsAndVararg.kt") + public void testManyDefaultsAndVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/manyDefaultsAndVararg.kt"); + } + + @TestMetadata("simpleDefaultArgument.kt") + public void testSimpleDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleDefaultArgument.kt"); + } + + @TestMetadata("simpleEmptyVararg.kt") + public void testSimpleEmptyVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleEmptyVararg.kt"); + } + + @TestMetadata("varargViewedAsArray.kt") + public void testVarargViewedAsArray() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/varargViewedAsArray.kt"); + } + + @TestMetadata("varargWithDefaultValue.kt") + public void testVarargWithDefaultValue() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/varargWithDefaultValue.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/casts") diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java index e56ad33f482..3227620e3ef 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java @@ -2245,6 +2245,69 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/callableReference/serializability/withReflect.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/callableReference/varargAndDefaults") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class VarargAndDefaults extends AbstractIrJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath); + } + + public void testAllFilesPresentInVarargAndDefaults() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/callableReference/varargAndDefaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JS_IR, true); + } + + @TestMetadata("boundReferences.kt") + public void testBoundReferences() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/boundReferences.kt"); + } + + @TestMetadata("defaultAfterVararg.kt") + public void testDefaultAfterVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultAfterVararg.kt"); + } + + @TestMetadata("defaultWithGenericExpectedType.kt") + public void testDefaultWithGenericExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultWithGenericExpectedType.kt"); + } + + @TestMetadata("emptyVarargAndDefault.kt") + public void testEmptyVarargAndDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/emptyVarargAndDefault.kt"); + } + + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/inline.kt"); + } + + @TestMetadata("manyDefaultsAndVararg.kt") + public void testManyDefaultsAndVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/manyDefaultsAndVararg.kt"); + } + + @TestMetadata("simpleDefaultArgument.kt") + public void testSimpleDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleDefaultArgument.kt"); + } + + @TestMetadata("simpleEmptyVararg.kt") + public void testSimpleEmptyVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleEmptyVararg.kt"); + } + + @TestMetadata("varargViewedAsArray.kt") + public void testVarargViewedAsArray() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/varargViewedAsArray.kt"); + } + + @TestMetadata("varargWithDefaultValue.kt") + public void testVarargWithDefaultValue() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/varargWithDefaultValue.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/casts") diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index 96662e4f8f5..5a1c1f29bd3 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -2265,6 +2265,69 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/callableReference/serializability/withReflect.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/callableReference/varargAndDefaults") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class VarargAndDefaults extends AbstractJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath); + } + + public void testAllFilesPresentInVarargAndDefaults() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/callableReference/varargAndDefaults"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JS, true); + } + + @TestMetadata("boundReferences.kt") + public void testBoundReferences() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/boundReferences.kt"); + } + + @TestMetadata("defaultAfterVararg.kt") + public void testDefaultAfterVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultAfterVararg.kt"); + } + + @TestMetadata("defaultWithGenericExpectedType.kt") + public void testDefaultWithGenericExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/defaultWithGenericExpectedType.kt"); + } + + @TestMetadata("emptyVarargAndDefault.kt") + public void testEmptyVarargAndDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/emptyVarargAndDefault.kt"); + } + + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/inline.kt"); + } + + @TestMetadata("manyDefaultsAndVararg.kt") + public void testManyDefaultsAndVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/manyDefaultsAndVararg.kt"); + } + + @TestMetadata("simpleDefaultArgument.kt") + public void testSimpleDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleDefaultArgument.kt"); + } + + @TestMetadata("simpleEmptyVararg.kt") + public void testSimpleEmptyVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/simpleEmptyVararg.kt"); + } + + @TestMetadata("varargViewedAsArray.kt") + public void testVarargViewedAsArray() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/varargViewedAsArray.kt"); + } + + @TestMetadata("varargWithDefaultValue.kt") + public void testVarargWithDefaultValue() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/varargAndDefaults/varargWithDefaultValue.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/casts")