Support default arguments and varargs for callable references

#KT-8834 #KT-19869 #KT-25514
2017-08-23 16:42:23 +03:00
parent f71909ee73
commit 9babd90999
17 changed files with 523 additions and 13 deletions
@@ -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<? extends ValueArgument> fakeArguments = fakeExpression.getValueArguments();

        ReceiverValue dispatchReceiver = computeAndSaveReceiver(signature, codegen, referencedFunction.getDispatchReceiverParameter());
@@ -106,11 +104,40 @@ public class FunctionReferenceGenerationStrategy extends FunctionGenerationStrat

            private final Map<ValueParameterDescriptor, ResolvedValueArgument> argumentMap = new LinkedHashMap<>();
            {
-                int index = 0;
-                List<ValueParameterDescriptor> 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<out T>. 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);
+                    }
                }
            }

@@ -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<ValueArgument> arguments = Lists.newArrayList();
+    private final List<ValueArgument> arguments;
+
+    public VarargValueArgument() {
+        this.arguments = new ArrayList<>();
+    }
+
+    public VarargValueArgument(@NotNull List<? extends ValueArgument> arguments) {
+        this.arguments = new ArrayList<>(arguments);
+    }

    public void addArgument(@NotNull ValueArgument argument) {
        arguments.add(argument);
@@ -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"
+}
@@ -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)
+}
@@ -0,0 +1,10 @@
+// !LANGUAGE: +NewInference
+// IGNORE_BACKEND: JS_IR, JVM_IR
+
+fun foo(x: String, y: Char = 'K'): String = x + y
+
+fun <T, U> call(f: (T) -> U, x: T): U = f(x)
+
+fun box(): String {
+    return call(::foo, "O")
+}
@@ -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)
+}
@@ -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)
@@ -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"
+}
@@ -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")
+}
@@ -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")
+}
@@ -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): String = f(1, Array(1) { "OK" })
+
+fun box(): String {
+    return useArray(::foo)
+}
@@ -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)
+}
@@ -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")
@@ -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")
@@ -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")
@@ -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")
@@ -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")