Support default arguments and varargs for callable references

#KT-8834
 #KT-19869
 #KT-25514

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"
+}

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)
+}

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 <T, U> call(f: (T) -> U, x: T): U = f(x)
+
+fun box(): String {
+    return call(::foo, "O")
+}

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)
+}

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)

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"
+}

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")
+}

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")
+}

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): String = f(1, Array(1) { "OK" })
+
+fun box(): String {
+    return useArray(::foo)
+}

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)
+}