J2K: replace overloads with optional parameters not only for constructors but for methods too

2015-04-08 16:22:15 +03:00
parent ff4ff78307
commit f6e363abb8
23 changed files with 721 additions and 184 deletions
@@ -0,0 +1,17 @@
+class A {
+    private String s = "";
+    private int x = 0;
+
+    public A() {
+    }
+
+    public A(int p, String s){
+        this(p, s, 1);
+    }
+
+    public A(int p, String s, int x) {
+        this();
+        this.s = s;
+        this.x = x;
+    }
+}
@@ -0,0 +1,11 @@
+// ERROR: Val cannot be reassigned
+// ERROR: Val cannot be reassigned
+class A() {
+    private val s = ""
+    private val x = 0
+
+    overloads public constructor(p: Int, s: String, x: Int = 1) : this() {
+        this.s = s
+        this.x = x
+    }
+}
@@ -0,0 +1,7 @@
+abstract class A {
+    public abstract void foo(int p);
+
+    public void foo(){
+        foo(1);
+    }
+}
@@ -0,0 +1,7 @@
+abstract class A {
+    public abstract fun foo(p: Int)
+
+    public fun foo() {
+        foo(1)
+    }
+}
@@ -0,0 +1,15 @@
+class A {
+    private int field = 0;
+
+    public int getField() {
+        return field;
+    }
+
+    public void setField(int field) {
+        this.field = field;
+    }
+
+    public void setField() {
+        setField(0);
+    }
+}
@@ -0,0 +1,7 @@
+class A {
+    public var field: Int = 0
+
+    public fun setField() {
+        field = 0
+    }
+}
@@ -0,0 +1,44 @@
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+class A {
+    @NotNull
+    Object foo(String s) {
+        System.out.println("s = " + s);
+        return "";
+    }
+
+    @NotNull
+    Object foo() {
+        return foo(null);
+    }
+
+    @Nullable
+    Object bar(String s) {
+        System.out.println("s = " + s);
+        return s == null ? "" : null;
+    }
+
+    @NotNull
+    Object bar() {
+        return bar(null);
+    }
+
+    public @Nullable Object bar1(String s) {
+        System.out.println("s = " + s);
+        return s == null ? "" : null;
+    }
+
+    public @NotNull Object bar1() {
+        return bar1(null);
+    }
+
+    @Deprecated
+    public void f() {
+        f(1);
+    }
+
+    public void f(int p) {
+        System.out.println("p = " + p);
+    }
+}
@@ -0,0 +1,35 @@
+// ERROR: Type mismatch: inferred type is kotlin.Any? but kotlin.Any was expected
+// ERROR: Type mismatch: inferred type is kotlin.Any? but kotlin.Any was expected
+class A {
+    overloads fun foo(s: String? = null): Any {
+        println("s = " + s!!)
+        return ""
+    }
+
+    fun bar(s: String?): Any? {
+        println("s = " + s!!)
+        return if (s == null) "" else null
+    }
+
+    fun bar(): Any {
+        return bar(null)
+    }
+
+    public fun bar1(s: String?): Any? {
+        println("s = " + s!!)
+        return if (s == null) "" else null
+    }
+
+    public fun bar1(): Any {
+        return bar1(null)
+    }
+
+    deprecated("")
+    public fun f() {
+        f(1)
+    }
+
+    public fun f(p: Int) {
+        println("p = " + p)
+    }
+}
@@ -0,0 +1,46 @@
+interface I {
+    void foo(int i, char c, String s);
+    void bar();
+}
+
+class A implements I{
+    public void foo(int i, char c, String s) {
+        System.out.println("foo" + i + c + s);
+    }
+
+    public void foo(int i, char c) {
+        foo(i, c, "");
+    }
+
+    public void foo(int i) {
+        foo(i, 'a', "");
+    }
+
+    public void bar() {
+        bar(1);
+    }
+
+    public void bar(int i) {}
+
+    public void x() {
+        x(1);
+    }
+
+    public void x(int i) {}
+
+    public void y() {
+        y(1);
+    }
+
+    public void y(int i) {}
+}
+
+class B extends A {
+    public void x() {
+        super.x();
+    }
+
+    public void y(int i) {
+        super.y(i);
+    }
+}
@@ -0,0 +1,49 @@
+trait I {
+    public fun foo(i: Int, c: Char, s: String)
+    public fun bar()
+}
+
+open class A : I {
+    override fun foo(i: Int, c: Char, s: String) {
+        println("foo" + i + c + s)
+    }
+
+    public fun foo(i: Int, c: Char) {
+        foo(i, c, "")
+    }
+
+    public fun foo(i: Int) {
+        foo(i, 'a', "")
+    }
+
+    override fun bar() {
+        bar(1)
+    }
+
+    public fun bar(i: Int) {
+    }
+
+    public open fun x() {
+        x(1)
+    }
+
+    public fun x(i: Int) {
+    }
+
+    public fun y() {
+        y(1)
+    }
+
+    public open fun y(i: Int) {
+    }
+}
+
+class B : A() {
+    override fun x() {
+        super.x()
+    }
+
+    override fun y(i: Int) {
+        super.y(i)
+    }
+}
@@ -0,0 +1,22 @@
+class A {
+    void foo(int i, char c, String s) {
+        System.out.println("foo" + i + c + s);
+    }
+
+    void foo(int i, char c) {
+        foo(i, c, "");
+    }
+
+    void foo(int i) {
+        foo(i, 'a', "");
+    }
+
+    int bar(String s) {
+        System.out.println("s = " + s);
+        return 0;
+    }
+
+    int bar() {
+        return bar(null);
+    }
+}
@@ -0,0 +1,10 @@
+class A {
+    overloads fun foo(i: Int, c: Char = 'a', s: String = "") {
+        println("foo" + i + c + s)
+    }
+
+    overloads fun bar(s: String? = null): Int {
+        println("s = " + s!!)
+        return 0
+    }
+}
@@ -0,0 +1,12 @@
+class A {
+    public void foo(int p) {
+        System.out.println("p = [" + p + "]");
+    }
+
+    public synchronized void foo(){
+        foo(calcSomething());
+    }
+
+    // this method should be invoked under synchronized block!
+    private int calcSomething() { return 0; }
+}
@@ -0,0 +1,14 @@
+class A {
+    public fun foo(p: Int) {
+        println("p = [" + p + "]")
+    }
+
+    synchronized public fun foo() {
+        foo(calcSomething())
+    }
+
+    // this method should be invoked under synchronized block!
+    private fun calcSomething(): Int {
+        return 0
+    }
+}