Change Signature: Propagate parameters to chosen callers

#KT-7902 Fixed

idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationAfter.1.kt

@@ -0,0 +1,18 @@
+open class C(n: Int) : A(n) {
+
+}
+
+open class D: A {
+    constructor(n: Int): super(n)
+    constructor(b: Boolean, n: Int) : super(n)
+}
+
+fun test(n: Int) {
+    A(n)
+    A(false, n)
+    B(n)
+    B(false, n)
+    C(n)
+    D(n)
+    D(false, n)
+}

idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationAfter.java

@@ -0,0 +1,32 @@
+class A {
+    public <caret>A(int n) {
+
+    }
+
+    public A(boolean b, int n) {
+        this(n);
+    }
+}
+
+class B extends A {
+    public B(int n) {
+
+        super(n);
+    }
+
+    public B(boolean b, int n) {
+        super(n);
+    }
+}
+
+class Test {
+    void test(int n) {
+        new A(n);
+        new A(true, n);
+        new B(n);
+        new B(true, n);
+        new C(n);
+        new D(n);
+        new D(true, n);
+    }
+}

idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationBefore.1.kt

@@ -0,0 +1,18 @@
+open class C: A() {
+
+}
+
+open class D: A {
+    constructor(): super()
+    constructor(b: Boolean)
+}
+
+fun test() {
+    A()
+    A(false)
+    B()
+    B(false)
+    C()
+    D()
+    D(false)
+}

idea/testData/refactoring/changeSignature/JavaConstructorParameterPropagationBefore.java

@@ -0,0 +1,31 @@
+class A {
+    public <caret>A() {
+
+    }
+
+    public A(boolean b) {
+        this();
+    }
+}
+
+class B extends A {
+    public B() {
+
+    }
+
+    public B(boolean b) {
+        super();
+    }
+}
+
+class Test {
+    void test() {
+        new A();
+        new A(true);
+        new B();
+        new B(true);
+        new C();
+        new D();
+        new D(true);
+    }
+}

idea/testData/refactoring/changeSignature/JavaParameterPropagationAfter.1.kt

@@ -0,0 +1,28 @@
+open class C: A() {
+    override fun foo(n: Int, s: String): Unit {
+
+    }
+
+    override fun bar(b: Boolean, n: Int, s: String) {
+        foo(n, s)
+    }
+
+    override fun baz() {
+        foo(1, "abc")
+        bar(false, 1, "abc")
+    }
+}
+
+fun test(n: Int, s: String) {
+    A().foo(n, s)
+    A().bar(true, n, s)
+    A().baz()
+
+    B().foo(n, s)
+    B().bar(true, n, s)
+    B().baz()
+
+    C().foo(n, s)
+    C().bar(true, n, s)
+    C().baz()
+}

idea/testData/refactoring/changeSignature/JavaParameterPropagationAfter.java

@@ -0,0 +1,45 @@
+class A {
+    public void foo(int n, String s) {
+
+    }
+
+    public void bar(boolean b, int n, String s) {
+        foo(n, s);
+    }
+
+    public void baz() {
+        foo(1, "abc");
+        bar(false, 1, "abc");
+    }
+}
+
+class B extends A {
+    public void foo(int n, String s) {
+
+    }
+
+    public void bar(boolean b, int n, String s) {
+        foo(1, "abc");
+    }
+
+    public void baz() {
+        foo(1, "abc");
+        bar(false, 1, "abc");
+    }
+}
+
+class Test {
+    void test() {
+        new A().foo(1, "abc");
+        new A().bar(true, 1, "abc");
+        new A().baz();
+
+        new B().foo(1, "abc");
+        new B().bar(true, 1, "abc");
+        new B().baz();
+
+        new C().foo(1, "abc");
+        new C().bar(true, 1, "abc");
+        new C().baz();
+    }
+}

idea/testData/refactoring/changeSignature/JavaParameterPropagationBefore.1.kt

@@ -0,0 +1,28 @@
+open class C: A() {
+    override fun foo() {
+
+    }
+
+    override fun bar(b: Boolean) {
+        foo()
+    }
+
+    override fun baz() {
+        foo()
+        bar(false)
+    }
+}
+
+fun test() {
+    A().foo()
+    A().bar(true)
+    A().baz()
+
+    B().foo()
+    B().bar(true)
+    B().baz()
+
+    C().foo()
+    C().bar(true)
+    C().baz()
+}

idea/testData/refactoring/changeSignature/JavaParameterPropagationBefore.java

@@ -0,0 +1,45 @@
+class A {
+    public void <caret>foo() {
+
+    }
+
+    public void bar(boolean b) {
+        foo();
+    }
+
+    public void baz() {
+        foo();
+        bar(false);
+    }
+}
+
+class B extends A {
+    public void foo() {
+
+    }
+
+    public void bar(boolean b) {
+        foo();
+    }
+
+    public void baz() {
+        foo();
+        bar(false);
+    }
+}
+
+class Test {
+    void test() {
+        new A().foo();
+        new A().bar(true);
+        new A().baz();
+
+        new B().foo();
+        new B().bar(true);
+        new B().baz();
+
+        new C().foo();
+        new C().bar(true);
+        new C().baz();
+    }
+}

idea/testData/refactoring/changeSignature/ParameterPropagationAfter.1.java

@@ -0,0 +1,35 @@
+import org.jetbrains.annotations.NotNull;
+
+class J extends A {
+    @Override
+    public void foo(int n, @NotNull String s) {
+
+    }
+
+    @Override
+    public void bar(boolean b, int n, String s) {
+        foo(1, "abc"); // Propagated parameters are not passed to calles in overriding methods
+    }
+
+    @Override
+    public void baz() {
+        foo(1, "abc");
+        bar(false, 1, "abc");
+    }
+}
+
+class Test {
+    void test() {
+        new A().foo(1, "abc");
+        new A().bar(true, 1, "abc");
+        new A().baz();
+
+        new B().foo(1, "abc");
+        new B().bar(true, 1, "abc");
+        new B().baz();
+
+        new J().foo(1, "abc");
+        new J().bar(true, 1, "abc");
+        new J().baz();
+    }
+}

idea/testData/refactoring/changeSignature/ParameterPropagationAfter.kt

@@ -0,0 +1,43 @@
+open class A {
+    open fun <caret>foo(n: Int, s: String) {
+
+    }
+
+    open fun bar(b: Boolean, n: Int, s: String) {
+        foo(n, s)
+    }
+
+    open fun baz() {
+        foo(1, "abc")
+        bar(false, 1, "abc")
+    }
+}
+
+class B : A() {
+    override fun foo(n: Int, s: String) {
+
+    }
+
+    override fun bar(b: Boolean, n: Int, s: String) {
+        foo(n, s)
+    }
+
+    override fun baz() {
+        foo(1, "abc")
+        bar(false, 1, "abc")
+    }
+}
+
+fun test(n: Int, s: String) {
+    A().foo(n, s)
+    A().bar(true, n, s)
+    A().baz()
+
+    B().foo(n, s)
+    B().bar(true, n, s)
+    B().baz()
+
+    J().foo(n, s)
+    J().bar(true, n, s)
+    J().baz()
+}

idea/testData/refactoring/changeSignature/ParameterPropagationBefore.1.java

@@ -0,0 +1,33 @@
+class J extends A {
+    @Override
+    public void foo() {
+
+    }
+
+    @Override
+    public void bar(boolean b) {
+        foo(); // Propagated parameters are not passed to calles in overriding methods
+    }
+
+    @Override
+    public void baz() {
+        foo();
+        bar(false);
+    }
+}
+
+class Test {
+    void test() {
+        new A().foo();
+        new A().bar(true);
+        new A().baz();
+
+        new B().foo();
+        new B().bar(true);
+        new B().baz();
+
+        new J().foo();
+        new J().bar(true);
+        new J().baz();
+    }
+}

idea/testData/refactoring/changeSignature/ParameterPropagationBefore.kt

@@ -0,0 +1,43 @@
+open class A {
+    open fun <caret>foo() {
+
+    }
+
+    open fun bar(b: Boolean) {
+        foo()
+    }
+
+    open fun baz() {
+        foo()
+        bar(false)
+    }
+}
+
+class B : A() {
+    override fun foo() {
+
+    }
+
+    override fun bar(b: Boolean) {
+        foo()
+    }
+
+    override fun baz() {
+        foo()
+        bar(false)
+    }
+}
+
+fun test() {
+    A().foo()
+    A().bar(true)
+    A().baz()
+
+    B().foo()
+    B().bar(true)
+    B().baz()
+
+    J().foo()
+    J().bar(true)
+    J().baz()
+}

idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationAfter.1.java

@@ -0,0 +1,22 @@
+class J extends A {
+    public J(int n) {
+
+        super(n);
+    }
+
+    public J(boolean b, int n) {
+        super(n);
+    }
+}
+
+class Test {
+    void test(int n) {
+        new A(n);
+        new A(true, n);
+        new B(n);
+        new B(true, n);
+        new C(true, n);
+        new J(n);
+        new J(true, n);
+    }
+}

idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationAfter.kt

@@ -0,0 +1,21 @@
+open class <caret>A(n: Int) {
+    constructor(b: Boolean, n: Int): this(n)
+}
+
+open class B: A {
+    constructor(n: Int) : super(n)
+
+    constructor(b: Boolean, n: Int): super(n)
+}
+
+open class C(b: Boolean, n: Int): A(n)
+
+fun test(n: Int) {
+    A(n)
+    A(false, n)
+    B(n)
+    B(false, n)
+    C(false, n)
+    J(n)
+    J(false, n)
+}

idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationBefore.1.java

@@ -0,0 +1,21 @@
+class J extends A {
+    public J() {
+
+    }
+
+    public J(boolean b) {
+        super();
+    }
+}
+
+class Test {
+    void test() {
+        new A();
+        new A(true);
+        new B();
+        new B(true);
+        new C(true);
+        new J();
+        new J(true);
+    }
+}

idea/testData/refactoring/changeSignature/PrimaryConstructorParameterPropagationBefore.kt

@@ -0,0 +1,20 @@
+open class <caret>A() {
+    constructor(b: Boolean): this()
+}
+
+open class B: A {
+    constructor()
+    constructor(b: Boolean): super()
+}
+
+open class C(b: Boolean): A()
+
+fun test() {
+    A()
+    A(false)
+    B()
+    B(false)
+    C(false)
+    J()
+    J(false)
+}

idea/testData/refactoring/changeSignature/PropagateWithParameterDuplicationBefore.kt

@@ -0,0 +1,5 @@
+fun <caret>foo() = 1
+
+fun bar(n: Int): Int {
+    return foo() + n
+}

idea/testData/refactoring/changeSignature/PropagateWithParameterDuplicationMessages.txt

@@ -0,0 +1 @@
+There is already a parameter 'n' in fun bar(n: Int): Int. It will conflict with the new parameter.

idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInClassMemberAfter.kt

@@ -0,0 +1,7 @@
+fun <caret>foo(n: Int): Int = 1
+
+class A(val n: Int) {
+    fun bar(n: Int): Int {
+        return foo(n) + this.n
+    }
+}

idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInClassMemberBefore.kt

@@ -0,0 +1,7 @@
+fun <caret>foo(): Int = 1
+
+class A(val n: Int) {
+    fun bar(): Int {
+        return foo() + n
+    }
+}

idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInExtensionAfter.kt

@@ -0,0 +1,7 @@
+fun <caret>foo(n: Int): Int = 1
+
+class A(val n: Int)
+
+fun A.bar(n: Int): Int {
+    return foo(n) + this.n
+}

idea/testData/refactoring/changeSignature/PropagateWithThisQualificationInExtensionBefore.kt

@@ -0,0 +1,7 @@
+fun <caret>foo(): Int = 1
+
+class A(val n: Int)
+
+fun A.bar(): Int {
+    return foo() + n
+}

idea/testData/refactoring/changeSignature/PropagateWithVariableDuplicationBefore.kt

@@ -0,0 +1,7 @@
+fun <caret>foo() = 1
+
+val n = 1
+
+fun bar(): Int {
+    return foo() + n
+}

idea/testData/refactoring/changeSignature/PropagateWithVariableDuplicationMessages.txt

@@ -0,0 +1 @@
+There is already a variable 'n' in fun bar(): Int. It will conflict with the new parameter.

idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationAfter.1.java

@@ -0,0 +1,22 @@
+class J extends A {
+    public J(int n) {
+
+        super(n);
+    }
+
+    public J(boolean b, int n) {
+        super(n);
+    }
+}
+
+class Test {
+    void test(int n) {
+        new A(n);
+        new A(true, n);
+        new B(n);
+        new B(true, n);
+        new C(true, n);
+        new J(n);
+        new J(true, n);
+    }
+}

idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationAfter.kt

@@ -0,0 +1,21 @@
+open class A {
+    <caret>constructor(n: Int)
+    constructor(b: Boolean, n: Int): this(n)
+}
+
+open class B: A {
+    constructor(n: Int) : super(n)
+
+    constructor(b: Boolean, n: Int): super(n)
+}
+
+open class C(b: Boolean, n: Int): A(n)
+
+fun test(n: Int) {
+    A(n)
+    A(false, n)
+    B(n)
+    B(false, n)
+    C(false, n)
+    J(n)
+}

idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationBefore.1.java

@@ -0,0 +1,21 @@
+class J extends A {
+    public J() {
+
+    }
+
+    public J(boolean b) {
+        super();
+    }
+}
+
+class Test {
+    void test() {
+        new A();
+        new A(true);
+        new B();
+        new B(true);
+        new C(true);
+        new J();
+        new J(true);
+    }
+}

idea/testData/refactoring/changeSignature/SecondaryConstructorParameterPropagationBefore.kt

@@ -0,0 +1,20 @@
+open class A {
+    <caret>constructor()
+    constructor(b: Boolean): this()
+}
+
+open class B: A {
+    constructor()
+    constructor(b: Boolean): super()
+}
+
+open class C(b: Boolean): A()
+
+fun test() {
+    A()
+    A(false)
+    B()
+    B(false)
+    C(false)
+    J()
+}