Extract Function: Type parameters inference

idea/testData/refactoring/extractFunction/typeParameters/localClassInBound.kt

@@ -0,0 +1,8 @@
+// NEXT_SIBLING:
+fun foo() {
+    open class X(val x: Int)
+
+    fun bar<T: X>(t: T): Int {
+        return <selection>t.x + 1</selection>
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/localClassInBound.kt.conflicts

@@ -0,0 +1 @@
+Cannot extract method since following types are not denotable in the target scope: foo.X

idea/testData/refactoring/extractFunction/typeParameters/localClassInTypeConstraint.kt

@@ -0,0 +1,8 @@
+// NEXT_SIBLING:
+fun foo() {
+    open class X(val x: Int)
+
+    fun bar<T>(t: T): Int where T: X {
+        return <selection>t.x + 1</selection>
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/localClassInTypeConstraint.kt.conflicts

@@ -0,0 +1 @@
+Cannot extract method since following types are not denotable in the target scope: foo.X

idea/testData/refactoring/extractFunction/typeParameters/simpleTypeParameter.kt

@@ -0,0 +1,8 @@
+open class Data(val x: Int)
+
+class Pair<A, B>(val a: A, val b: B)
+
+// NEXT_SIBLING:
+fun foo<V: Data>(v: V): Pair<Int, V> {
+    return <selection>Pair(v.x + 10, v)</selection>
+}

idea/testData/refactoring/extractFunction/typeParameters/simpleTypeParameter.kt.after

@@ -0,0 +1,12 @@
+open class Data(val x: Int)
+
+class Pair<A, B>(val a: A, val b: B)
+
+// NEXT_SIBLING:
+fun <V : Data> pair(v: V): Pair<Int, V> {
+    return Pair(v.x + 10, v)
+}
+
+fun foo<V: Data>(v: V): Pair<Int, V> {
+    return pair(v)
+}

idea/testData/refactoring/extractFunction/typeParameters/simpleTypeParameterWithConstraint.kt

@@ -0,0 +1,9 @@
+open class Data(val x: Int)
+trait DataEx
+
+class Pair<A, B>(val a: A, val b: B)
+
+// NEXT_SIBLING:
+fun foo<V: Data>(v: V): Pair<Int, V> where V: DataEx {
+    return <selection>Pair(v.x + 10, v)</selection>
+}

idea/testData/refactoring/extractFunction/typeParameters/simpleTypeParameterWithConstraint.kt.after

@@ -0,0 +1,13 @@
+open class Data(val x: Int)
+trait DataEx
+
+class Pair<A, B>(val a: A, val b: B)
+
+// NEXT_SIBLING:
+fun <V : Data> pair(v: V): Pair<Int, V> where V : DataEx {
+    return Pair(v.x + 10, v)
+}
+
+fun foo<V: Data>(v: V): Pair<Int, V> where V: DataEx {
+    return pair(v)
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParamInArgument.kt

@@ -0,0 +1,8 @@
+class Data<T>(val t: Int)
+
+// NEXT_SIBLING:
+class A<T> {
+    fun foo(d: Data<T>): Int {
+        return <selection>d.t + 1</selection>
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParamInArgument.kt.after

@@ -0,0 +1,12 @@
+class Data<T>(val t: Int)
+
+// NEXT_SIBLING:
+fun <T> i(d: Data<T>): Int {
+    return d.t + 1
+}
+
+class A<T> {
+    fun foo(d: Data<T>): Int {
+        return i(d)
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersAndConstraintsCombined1.kt

@@ -0,0 +1,12 @@
+open class Data(val x: Int)
+trait DataEx
+trait DataExEx
+
+// NEXT_SIBLING:
+class A<T: Data>(val t: T) where T: DataEx {
+    inner class B<U: Data>(val u: U) where U: DataExEx {
+        fun foo<V: Data>(v: V): Int where V: DataEx {
+            return <selection>t.x + u.x + v.x</selection>
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersAndConstraintsCombined1.kt.after

@@ -0,0 +1,16 @@
+open class Data(val x: Int)
+trait DataEx
+trait DataExEx
+
+// NEXT_SIBLING:
+fun <T : Data, U : Data, V : Data> i(a: A<T>, b: A.B<U>, v: V): Int where T : DataEx, U : DataExEx, V : DataEx {
+    return a.t.x + b.u.x + v.x
+}
+
+class A<T: Data>(val t: T) where T: DataEx {
+    inner class B<U: Data>(val u: U) where U: DataExEx {
+        fun foo<V: Data>(v: V): Int where V: DataEx {
+            return i(this@A, this@B, v)
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersAndConstraintsCombined2.kt

@@ -0,0 +1,12 @@
+open class Data(val x: Int)
+trait DataEx
+trait DataExEx
+
+class A<T: Data>(val t: T) where T: DataEx {
+    // NEXT_SIBLING:
+    inner class B<U: Data>(val u: U) where U: DataExEx {
+        fun foo<V: Data>(v: V): Int where V: DataEx {
+            return <selection>t.x + u.x + v.x</selection>
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersAndConstraintsCombined2.kt.after

@@ -0,0 +1,16 @@
+open class Data(val x: Int)
+trait DataEx
+trait DataExEx
+
+class A<T: Data>(val t: T) where T: DataEx {
+    // NEXT_SIBLING:
+    fun <U : Data, V : Data> B<U>.i(v: V): Int where U : DataExEx, V : DataEx {
+        return t.x + u.x + v.x
+    }
+
+    inner class B<U: Data>(val u: U) where U: DataExEx {
+        fun foo<V: Data>(v: V): Int where V: DataEx {
+            return i(v)
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersAndConstraintsCombined3.kt

@@ -0,0 +1,12 @@
+open class Data(val x: Int)
+trait DataEx
+trait DataExEx
+
+class A<T: Data>(val t: T) where T: DataEx {
+    inner class B<U: Data>(val u: U) where U: DataExEx {
+        // NEXT_SIBLING:
+        fun foo<V: Data>(v: V): Int where V: DataEx {
+            return <selection>t.x + u.x + v.x</selection>
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersAndConstraintsCombined3.kt.after

@@ -0,0 +1,16 @@
+open class Data(val x: Int)
+trait DataEx
+trait DataExEx
+
+class A<T: Data>(val t: T) where T: DataEx {
+    inner class B<U: Data>(val u: U) where U: DataExEx {
+        // NEXT_SIBLING:
+        fun <V : Data> i(v: V): Int where V : DataEx {
+            return t.x + u.x + v.x
+        }
+
+        fun foo<V: Data>(v: V): Int where V: DataEx {
+            return i(v)
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersCombined1.kt

@@ -0,0 +1,10 @@
+open class Data(val x: Int)
+
+// NEXT_SIBLING:
+class A<T: Data>(val t: T) {
+    inner class B<U: Data>(val u: U) {
+        fun foo<V: Data>(v: V): Int {
+            return <selection>t.x + u.x + v.x</selection>
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersCombined1.kt.after

@@ -0,0 +1,14 @@
+open class Data(val x: Int)
+
+// NEXT_SIBLING:
+fun <T : Data, U : Data, V : Data> i(a: A<T>, b: A.B<U>, v: V): Int {
+    return a.t.x + b.u.x + v.x
+}
+
+class A<T: Data>(val t: T) {
+    inner class B<U: Data>(val u: U) {
+        fun foo<V: Data>(v: V): Int {
+            return i(this@A, this@B, v)
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersCombined2.kt

@@ -0,0 +1,10 @@
+open class Data(val x: Int)
+
+class A<T: Data>(val t: T) {
+    // NEXT_SIBLING:
+    inner class B<U: Data>(val u: U) {
+        fun foo<V: Data>(v: V): Int {
+            return <selection>t.x + u.x + v.x</selection>
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersCombined2.kt.after

@@ -0,0 +1,14 @@
+open class Data(val x: Int)
+
+class A<T: Data>(val t: T) {
+    // NEXT_SIBLING:
+    fun <U : Data, V : Data> B<U>.i(v: V): Int {
+        return t.x + u.x + v.x
+    }
+
+    inner class B<U: Data>(val u: U) {
+        fun foo<V: Data>(v: V): Int {
+            return i(v)
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersCombined3.kt

@@ -0,0 +1,10 @@
+open class Data(val x: Int)
+
+class A<T: Data>(val t: T) {
+    inner class B<U: Data>(val u: U) {
+        // NEXT_SIBLING:
+        fun foo<V: Data>(v: V): Int {
+            return <selection>t.x + u.x + v.x</selection>
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersCombined3.kt.after

@@ -0,0 +1,14 @@
+open class Data(val x: Int)
+
+class A<T: Data>(val t: T) {
+    inner class B<U: Data>(val u: U) {
+        // NEXT_SIBLING:
+        fun <V : Data> i(v: V): Int {
+            return t.x + u.x + v.x
+        }
+
+        fun foo<V: Data>(v: V): Int {
+            return i(v)
+        }
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersCombinedAndThis.kt

@@ -0,0 +1,9 @@
+open class Data(val x: Int)
+trait DataEx
+
+// NEXT_SIBLING:
+class A<T: Data>(val t: T) where T: DataEx {
+    fun foo<V: Data>(v: V): Int {
+        return <selection>t.x + v.x</selection>
+    }
+}

idea/testData/refactoring/extractFunction/typeParameters/typeParametersCombinedAndThis.kt.after

@@ -0,0 +1,13 @@
+open class Data(val x: Int)
+trait DataEx
+
+// NEXT_SIBLING:
+fun <T : Data, V : Data> A<T>.i(v: V): Int where T : DataEx {
+    return t.x + v.x
+}
+
+class A<T: Data>(val t: T) where T: DataEx {
+    fun foo<V: Data>(v: V): Int {
+        return i(v)
+    }
+}