Create From Usage: Quick-fix for value parameters

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInAccessorInClass.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A(val foo: Int) {
+    val test: Int get() {
+        return foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInAccessorInGenClass.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A<T>(val foo: T) {
+    val test: T get() {
+        return foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInAccessorWithExpressionBodyInClass.kt

@@ -0,0 +1,5 @@
+// "Create parameter 'foo'" "true"
+
+class A(val foo: Int) {
+    val test: Int get() = foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInClassInitializer.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A(foo: Int) {
+    {
+        val t: Int = foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInFun.kt

@@ -0,0 +1,6 @@
+// "Create parameter 'foo'" "true"
+
+fun test(n: Int,
+         foo: Int) {
+    val t: Int = foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInFunInClass.kt

@@ -0,0 +1,8 @@
+// "Create parameter 'foo'" "true"
+
+class A {
+    fun test(n: Int,
+             foo: Int) {
+        val t: Int = foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInFunInGenClass.kt

@@ -0,0 +1,8 @@
+// "Create parameter 'foo'" "true"
+
+class A<T> {
+    fun test(n: Int,
+             foo: T) {
+        val t: T = foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInGenFunInClass.kt

@@ -0,0 +1,8 @@
+// "Create parameter 'foo'" "true"
+
+class A {
+    fun test<T>(n: Int,
+                foo: T) {
+        val t: T = foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInGenFunInGenClass.kt

@@ -0,0 +1,8 @@
+// "Create parameter 'foo'" "true"
+
+class A<T> {
+    fun test<T>(n: Int,
+                foo: T) {
+        val t: T = foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInLambdaNoParams.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+// ACTION: Create local variable 'foo'
+
+fun test(n: Int,
+         foo: Int) {
+    val f: () -> Int = { foo }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInLambdaWithIt.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+// ACTION: Create local variable 'foo'
+
+fun test(n: Int,
+         foo: Int) {
+    val f: (Int) -> Int = { foo }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInLambdaWithParams.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+// ACTION: Create local variable 'foo'
+
+fun test(n: Int,
+         foo: Int) {
+    val f: (Int, Int) -> Int = { (a, b) -> foo }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInLambdaWithTypedParams.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+// ACTION: Create local variable 'foo'
+
+fun test(n: Int,
+         foo: Any) {
+    val f = { (a: Int, b: Int) -> foo }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInMultiLineLambdaNoParams.kt

@@ -0,0 +1,9 @@
+// "Create parameter 'foo'" "true"
+// ACTION: Create local variable 'foo'
+
+fun test(n: Int,
+         foo: Int) {
+    val f: () -> Int = {
+        foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInPropertyInitializerInClass.kt

@@ -0,0 +1,5 @@
+// "Create parameter 'foo'" "true"
+
+class A(foo: Int) {
+    val test: Int = <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInPropertyInitializerInEnumClass.kt

@@ -0,0 +1,12 @@
+// "Create parameter 'foo'" "true"
+// ERROR: Missing delegation specifier 'E'
+// ERROR: Missing delegation specifier 'E'
+// ERROR: Missing delegation specifier 'E'
+
+enum class E(foo: Int) {
+    A
+    B
+    C
+
+    val t: Int = foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInPropertyInitializerInEnumEntry.kt

@@ -0,0 +1,12 @@
+// "Create parameter 'foo'" "true"
+// ERROR: Missing delegation specifier 'E'
+// ERROR: Missing delegation specifier 'E'
+// ERROR: Missing delegation specifier 'E'
+
+enum class E(val foo: Int) {
+    A
+    B {
+        val t: Int = foo
+    }
+    C
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInPropertyInitializerInGenClass.kt

@@ -0,0 +1,5 @@
+// "Create parameter 'foo'" "true"
+
+class A<T>(foo: T) {
+    val test: T = foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInPropertyInitializerInNestedClass.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A {
+    class B(foo: Int) {
+        val test: Int = foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInAccessorInClass.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A {
+    val test: Int get() {
+        return <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInAccessorInClassObject.kt

@@ -0,0 +1,12 @@
+// "Create parameter 'foo'" "false"
+// ACTION: Convert to expression body
+// ACTION: Create local variable 'foo'
+// ERROR: Unresolved reference: foo
+
+class A {
+    class object {
+        val test: Int get() {
+            return <caret>foo
+        }
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInAccessorInGenClass.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A<T> {
+    val test: T get() {
+        return <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInAccessorInObject.kt

@@ -0,0 +1,10 @@
+// "Create parameter 'foo'" "false"
+// ACTION: Convert to expression body
+// ACTION: Create local variable 'foo'
+// ERROR: Unresolved reference: foo
+
+object A {
+    val test: Int get() {
+        return <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInAccessorInTrait.kt

@@ -0,0 +1,10 @@
+// "Create parameter 'foo'" "false"
+// ACTION: Convert to expression body
+// ACTION: Create local variable 'foo'
+// ERROR: Unresolved reference: foo
+
+trait A {
+    val test: Int get() {
+        return <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInAccessorNoClass.kt

@@ -0,0 +1,8 @@
+// "Create parameter 'foo'" "false"
+// ACTION: Convert to expression body
+// ACTION: Create local variable 'foo'
+// ERROR: Unresolved reference: foo
+
+val test: Int get() {
+    return <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInAccessorWithExpressionBodyInClass.kt

@@ -0,0 +1,5 @@
+// "Create parameter 'foo'" "true"
+
+class A {
+    val test: Int get() = <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInClassInitializer.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A {
+    {
+        val t: Int = <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInClassObjectInitializer.kt

@@ -0,0 +1,12 @@
+// "Create parameter 'foo'" "false"
+// ACTION: Create local variable 'foo'
+// ACTION: Split property declaration
+// ERROR: Unresolved reference: foo
+
+class A {
+    class object {
+        {
+            val t: Int = <caret>foo
+        }
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInFun.kt

@@ -0,0 +1,5 @@
+// "Create parameter 'foo'" "true"
+
+fun test(n: Int) {
+    val t: Int = <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInFunInClass.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A {
+    fun test(n: Int) {
+        val t: Int = <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInFunInGenClass.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A<T> {
+    fun test(n: Int) {
+        val t: T = <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInGenAccessorInClass.kt

@@ -0,0 +1,10 @@
+// "Create parameter 'foo'" "false"
+// ACTION: Convert to expression body
+// ACTION: Create local variable 'foo'
+// ERROR: Unresolved reference: foo
+
+class A {
+    val <T> test: T get() {
+        return <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInGenAccessorInGenClass.kt

@@ -0,0 +1,10 @@
+// "Create parameter 'foo'" "false"
+// ACTION: Convert to expression body
+// ACTION: Create local variable 'foo'
+// ERROR: Unresolved reference: foo
+
+class A<T> {
+    val <T> test: T get() {
+        return <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInGenFunInClass.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A {
+    fun test<T>(n: Int) {
+        val t: T = <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInGenFunInGenClass.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A<T> {
+    fun test<T>(n: Int) {
+        val t: T = <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInGenPropertyInitializerInClass.kt

@@ -0,0 +1,6 @@
+// "Create parameter 'foo'" "false"
+// ERROR: Unresolved reference: foo
+
+class A {
+    val <T> test: T = <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInGenPropertyInitializerInGenClass.kt

@@ -0,0 +1,6 @@
+// "Create parameter 'foo'" "false"
+// ERROR: Unresolved reference: foo
+
+class A<T> {
+    val <T> test: T = <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInLambdaNoParams.kt

@@ -0,0 +1,6 @@
+// "Create parameter 'foo'" "true"
+// ACTION: Create local variable 'foo'
+
+fun test(n: Int) {
+    val f: () -> Int = { <caret>foo }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInLambdaWithIt.kt

@@ -0,0 +1,6 @@
+// "Create parameter 'foo'" "true"
+// ACTION: Create local variable 'foo'
+
+fun test(n: Int) {
+    val f: (Int) -> Int = { <caret>foo }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInLambdaWithParams.kt

@@ -0,0 +1,6 @@
+// "Create parameter 'foo'" "true"
+// ACTION: Create local variable 'foo'
+
+fun test(n: Int) {
+    val f: (Int, Int) -> Int = { (a, b) -> <caret>foo }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInLambdaWithTypedParams.kt

@@ -0,0 +1,6 @@
+// "Create parameter 'foo'" "true"
+// ACTION: Create local variable 'foo'
+
+fun test(n: Int) {
+    val f = { (a: Int, b: Int) -> <caret>foo }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInMultiLineLambdaNoParams.kt

@@ -0,0 +1,8 @@
+// "Create parameter 'foo'" "true"
+// ACTION: Create local variable 'foo'
+
+fun test(n: Int) {
+    val f: () -> Int = {
+        <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInPropertyInitializerInClass.kt

@@ -0,0 +1,5 @@
+// "Create parameter 'foo'" "true"
+
+class A {
+    val test: Int = <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInPropertyInitializerInClassObject.kt

@@ -0,0 +1,8 @@
+// "Create parameter 'foo'" "false"
+// ERROR: Unresolved reference: foo
+
+class A {
+    class object {
+        val test: Int = <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInPropertyInitializerInEnumClass.kt

@@ -0,0 +1,12 @@
+// "Create parameter 'foo'" "true"
+// ERROR: Missing delegation specifier 'E'
+// ERROR: Missing delegation specifier 'E'
+// ERROR: Missing delegation specifier 'E'
+
+enum class E {
+    A
+    B
+    C
+
+    val t: Int = <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInPropertyInitializerInEnumEntry.kt

@@ -0,0 +1,12 @@
+// "Create parameter 'foo'" "true"
+// ERROR: Missing delegation specifier 'E'
+// ERROR: Missing delegation specifier 'E'
+// ERROR: Missing delegation specifier 'E'
+
+enum class E {
+    A
+    B {
+        val t: Int = <caret>foo
+    }
+    C
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInPropertyInitializerInGenClass.kt

@@ -0,0 +1,5 @@
+// "Create parameter 'foo'" "true"
+
+class A<T> {
+    val test: T = <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInPropertyInitializerInNestedClass.kt

@@ -0,0 +1,7 @@
+// "Create parameter 'foo'" "true"
+
+class A {
+    class B {
+        val test: Int = <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInPropertyInitializerInObject.kt

@@ -0,0 +1,6 @@
+// "Create parameter 'foo'" "false"
+// ERROR: Unresolved reference: foo
+
+object A {
+    val test: Int = <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInPropertyInitializerNoClass.kt

@@ -0,0 +1,4 @@
+// "Create parameter 'foo'" "false"
+// ERROR: Unresolved reference: foo
+
+val test: Int = <caret>foo

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeQualifiedInFun.kt

@@ -0,0 +1,9 @@
+// "Create parameter 'foo'" "false"
+// ACTION: Split property declaration
+// ERROR: Unresolved reference: foo
+
+class A
+
+fun test(a: A) {
+    val t: Int = a.<caret>foo
+}