Implement kotlin.jvm.overloads annotation for generating all overloads of a method that has default parameter values.

#KT-2095 Fixed

fix backend-side issues with kotlin.jvm.overloads: support the annotation on constructors, generate nullablity annotations on parameters, generate generic signatures, add various tests

compiler/testData/asJava/lightClasses/nullabilityAnnotations/JvmOverloads.java

@@ -0,0 +1,14 @@
+public final class C {
+    @org.jetbrains.annotations.NotNull
+    public final java.lang.String foo(@org.jetbrains.annotations.NotNull java.lang.String o, @org.jetbrains.annotations.NotNull java.lang.String s1, @org.jetbrains.annotations.NotNull java.lang.String k, @org.jetbrains.annotations.Nullable java.lang.String s2) { /* compiled code */ }
+
+    public static java.lang.String foo$default(C p, java.lang.String p1, java.lang.String p2, java.lang.String p3, java.lang.String p4, int p5) { /* compiled code */ }
+
+    @org.jetbrains.annotations.NotNull
+    public java.lang.String foo(@org.jetbrains.annotations.NotNull java.lang.String p, @org.jetbrains.annotations.NotNull java.lang.String p1, @org.jetbrains.annotations.Nullable java.lang.String p2) { /* compiled code */ }
+
+    @org.jetbrains.annotations.NotNull
+    public java.lang.String foo(@org.jetbrains.annotations.NotNull java.lang.String p, @org.jetbrains.annotations.Nullable java.lang.String p1) { /* compiled code */ }
+
+    public C() { /* compiled code */ }
+}

compiler/testData/asJava/lightClasses/nullabilityAnnotations/JvmOverloads.kt

@@ -0,0 +1,7 @@
+// C
+
+class C {
+    [kotlin.jvm.overloads] public fun foo(o: String = "O", s1: String, k: String = "K", s2: String?): String {
+        return o + k
+    }
+}

compiler/testData/codegen/boxWithJava/jvmOverloads/generics/Test.java

@@ -0,0 +1,6 @@
+public class Test {
+    public static String invokeMethodWithOverloads() {
+        C<String> c = new C<String>();
+        return c.foo("O");
+    }
+}

compiler/testData/codegen/boxWithJava/jvmOverloads/generics/generics.kt

@@ -0,0 +1,7 @@
+class C<T> {
+    [kotlin.jvm.overloads] public fun foo(o: T, k: String = "K"): String = o.toString() + k
+}
+
+fun box(): String {
+    return Test.invokeMethodWithOverloads()
+}

compiler/testData/codegen/boxWithJava/jvmOverloads/simple/Test.java

@@ -0,0 +1,6 @@
+public class Test {
+    public static String invokeMethodWithOverloads() {
+        C c = new C();
+        return c.foo();
+    }
+}

compiler/testData/codegen/boxWithJava/jvmOverloads/simple/simple.kt

@@ -0,0 +1,7 @@
+class C {
+    [kotlin.jvm.overloads] public fun foo(o: String = "O", k: String = "K"): String = o + k
+}
+
+fun box(): String {
+    return Test.invokeMethodWithOverloads()
+}

compiler/testData/codegen/boxWithStdlib/jvmOverloads/defaultsNotAtEnd.kt

@@ -0,0 +1,11 @@
+class C {
+    [kotlin.jvm.overloads] public fun foo(o: String = "O", i1: Int, k: String = "K", i2: Int): String {
+        return o + k
+    }
+}
+
+fun box(): String {
+    val c = C()
+    val m = c.javaClass.getMethod("foo", javaClass<Int>(), javaClass<Int>())
+    return m.invoke(c, 1, 2) as String
+}

compiler/testData/codegen/boxWithStdlib/jvmOverloads/primaryConstructor.kt

@@ -0,0 +1,8 @@
+class C [kotlin.jvm.overloads] (s1: String, s2: String = "K") {
+    public val status: String = s1 + s2
+}
+
+fun box(): String {
+    val c = (javaClass<C>().getConstructor(javaClass<String>()).newInstance("O"))
+    return c.status
+}

compiler/testData/codegen/boxWithStdlib/jvmOverloads/secondaryConstructor.kt

@@ -0,0 +1,12 @@
+class C(val i: Int) {
+    var status = "fail"
+
+    [kotlin.jvm.overloads] constructor(o: String, k: String = "K"): this(-1) {
+        status = o + k
+    }
+}
+
+fun box(): String {
+    val c = (javaClass<C>().getConstructor(javaClass<String>()).newInstance("O"))
+    return c.status
+}

compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmOverloads.kt

@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class <!CONFLICTING_JVM_DECLARATIONS!>A<!> {
+    [kotlin.jvm.overloads] fun foo(s: String = "") {
+    }
+
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo()<!> {
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmOverloads.txt

@@ -0,0 +1,10 @@
+package 
+
+internal final class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    internal final fun foo(): kotlin.Unit
+    kotlin.jvm.overloads() internal final fun foo(/*0*/ s: kotlin.String = ...): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}