Create From Usage: Quick-fix for properties

idea/testData/quickfix/createFromUsage/createVariable/localVariable/beforeInClass.kt

@@ -1,5 +1,6 @@
 // "Create local variable 'foo'" "false"
 // ACTION: Create parameter 'foo'
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 class A {

idea/testData/quickfix/createFromUsage/createVariable/localVariable/beforeOnTopLevel.kt

@@ -1,4 +1,5 @@
 // "Create local variable 'foo'" "false"
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 val t: Int = <caret>foo

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

@@ -1,4 +1,5 @@
 // "Create local variable 'foo'" "false"
+// ACTION: Create property 'foo' from usage
 // ACTION: Split property declaration
 // ERROR: Unresolved reference: foo
 

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

@@ -1,6 +1,7 @@
 // "Create parameter 'foo'" "false"
 // ACTION: Convert to expression body
 // ACTION: Create local variable 'foo'
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 class A {

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

@@ -1,6 +1,7 @@
 // "Create parameter 'foo'" "false"
 // ACTION: Convert to expression body
 // ACTION: Create local variable 'foo'
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 object A {

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

@@ -1,6 +1,7 @@
 // "Create parameter 'foo'" "false"
 // ACTION: Convert to expression body
 // ACTION: Create local variable 'foo'
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 trait A {

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

@@ -1,6 +1,7 @@
 // "Create parameter 'foo'" "false"
 // ACTION: Convert to expression body
 // ACTION: Create local variable 'foo'
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 val test: Int get() {

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

@@ -1,6 +1,7 @@
 // "Create parameter 'foo'" "false"
 // ACTION: Convert to expression body
 // ACTION: Create local variable 'foo'
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 class A {

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

@@ -1,6 +1,7 @@
 // "Create parameter 'foo'" "false"
 // ACTION: Convert to expression body
 // ACTION: Create local variable 'foo'
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 class A<T> {

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

@@ -1,5 +1,6 @@
 // "Create parameter 'foo'" "false"
 // ERROR: Unresolved reference: foo
+// ACTION: Create property 'foo' from usage
 
 class A {
     val <T> test: T = <caret>foo

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

@@ -1,4 +1,5 @@
 // "Create parameter 'foo'" "false"
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 class A<T> {

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

@@ -1,4 +1,5 @@
 // "Create parameter 'foo'" "false"
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 class A {

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

@@ -1,4 +1,5 @@
 // "Create parameter 'foo'" "false"
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 object A {

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

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

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

@@ -1,5 +1,6 @@
 // "Create parameter 'foo'" "false"
 // ACTION: Split property declaration
+// ACTION: Create property 'foo' from usage
 // ERROR: Unresolved reference: foo
 
 class A

idea/testData/quickfix/createFromUsage/createVariable/property/afterInconsistentTypes.kt

@@ -0,0 +1,12 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: <html>Type mismatch.<table><tr><td>Required:</td><td>kotlin.Int</td></tr><tr><td>Found:</td><td>A&lt;kotlin.Int&gt;</td></tr></table></html>
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    val foo: Any
+
+}
+
+fun test(): Int {
+    return A(1).foo as A<Int>
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterLocalValNoReceiver.kt

@@ -0,0 +1,9 @@
+// "Create property 'foo' from usage" "true"
+
+fun test() {
+    val foo: Int
+
+    fun nestedTest(): Int {
+        return foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterMemberValNoReceiver.kt

@@ -0,0 +1,12 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A {
+    class B {
+        val foo: Int
+
+        fun test(): Int {
+            return foo
+        }
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterObjectMemberValNoReceiver.kt

@@ -0,0 +1,12 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A {
+    object B {
+        val foo: Int
+
+        fun test(): Int {
+            return foo
+        }
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterThisInClass.kt

@@ -0,0 +1,10 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    val foo: A<Int>
+
+    fun test(): A<Int> {
+        return this.foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterThisInExtension.kt

@@ -0,0 +1,11 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    val foo: A<Int>
+
+}
+
+fun <U> A<U>.test(): A<Int> {
+    return this.foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterThisInNestedClass1.kt

@@ -0,0 +1,12 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    inner class B<U>(val m: U) {
+        val foo: A<Int>
+
+        fun test(): A<Int> {
+            return this.foo
+        }
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterThisInNestedClass2.kt

@@ -0,0 +1,12 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    val foo: A<Int>
+
+    inner class B<U>(val m: U) {
+        fun test(): A<Int> {
+            return this@A.foo
+        }
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterTopLevelValNoReceiver.kt

@@ -0,0 +1,8 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized
+
+fun test(): Int {
+    return foo
+}
+
+val foo: Int

idea/testData/quickfix/createFromUsage/createVariable/property/afterValOnClassObject.kt

@@ -0,0 +1,14 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    class object {
+
+        val foo: Int
+
+    }
+}
+
+fun test() {
+    val a: Int = A.foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterValOnLibObject.kt

@@ -0,0 +1,8 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized
+
+fun test() {
+    val a: Int = Unit.foo
+}
+
+val Unit.foo: Int

idea/testData/quickfix/createFromUsage/createVariable/property/afterValOnLibType.kt

@@ -0,0 +1,10 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized
+
+class A<T>(val n: T)
+
+fun test() {
+    val a: A<Int> = 2.foo
+}
+
+val Int.foo: A<Int>

idea/testData/quickfix/createFromUsage/createVariable/property/afterValOnUserObject.kt

@@ -0,0 +1,11 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+object A {
+    val foo: Int
+
+}
+
+fun test() {
+    val a: Int = A.foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterValOnUserType.kt

@@ -0,0 +1,11 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    val foo: A<T>
+
+}
+
+fun test() {
+    val a: A<Int> = A(1).foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/afterValOnUserTypeWithTypeParams.kt

@@ -0,0 +1,11 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    val foo: A<T>
+
+}
+
+fun test<U>(u: U) {
+    val a: A<U> = A(u).foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeCallOnUserType.kt

@@ -0,0 +1,13 @@
+// "Create property 'foo' from usage" "false"
+// ACTION: Create function 'bar' from usage
+// ACTION: Replace with infix function call
+// ERROR: Unresolved reference: bar
+// ERROR: Unresolved reference: foo
+
+class A<T>(val n: T) {
+    val foo: Int = 1
+}
+
+fun test() {
+    A(1).<caret>bar(foo)
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeInconsistentTypes.kt

@@ -0,0 +1,9 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: <html>Type mismatch.<table><tr><td>Required:</td><td>kotlin.Int</td></tr><tr><td>Found:</td><td>A&lt;kotlin.Int&gt;</td></tr></table></html>
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T)
+
+fun test(): Int {
+    return A(1).<caret>foo as A<Int>
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeLocalValNoReceiver.kt

@@ -0,0 +1,13 @@
+// "Create property 'foo' from usage" "false"
+// ACTION: Convert to expression body
+// ACTION: Disable 'Convert to Expression Body'
+// ACTION: Edit intention settings
+// ACTION: Create parameter 'foo'
+// ACTION: Create local variable 'foo'
+// ERROR: Unresolved reference: foo
+
+fun test() {
+    fun nestedTest(): Int {
+        return <caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeMemberValNoReceiver.kt

@@ -0,0 +1,10 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A {
+    class B {
+        fun test(): Int {
+            return <caret>foo
+        }
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeObjectMemberValNoReceiver.kt

@@ -0,0 +1,10 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A {
+    object B {
+        fun test(): Int {
+            return <caret>foo
+        }
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeThisInClass.kt

@@ -0,0 +1,8 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    fun test(): A<Int> {
+        return this.<caret>foo
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeThisInExtension.kt

@@ -0,0 +1,8 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T)
+
+fun <U> A<U>.test(): A<Int> {
+    return this.<caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeThisInNestedClass1.kt

@@ -0,0 +1,10 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    inner class B<U>(val m: U) {
+        fun test(): A<Int> {
+            return this.<caret>foo
+        }
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeThisInNestedClass2.kt

@@ -0,0 +1,10 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    inner class B<U>(val m: U) {
+        fun test(): A<Int> {
+            return this@A.<caret>foo
+        }
+    }
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeTopLevelValNoReceiver.kt

@@ -0,0 +1,6 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized
+
+fun test(): Int {
+    return <caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeValOnClassObject.kt

@@ -0,0 +1,12 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T) {
+    class object {
+
+    }
+}
+
+fun test() {
+    val a: Int = A.<caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeValOnLibObject.kt

@@ -0,0 +1,6 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized
+
+fun test() {
+    val a: Int = Unit.<caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeValOnLibType.kt

@@ -0,0 +1,8 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized
+
+class A<T>(val n: T)
+
+fun test() {
+    val a: A<Int> = 2.<caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeValOnUserObject.kt

@@ -0,0 +1,8 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+object A
+
+fun test() {
+    val a: Int = A.<caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeValOnUserType.kt

@@ -0,0 +1,8 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T)
+
+fun test() {
+    val a: A<Int> = A(1).<caret>foo
+}

idea/testData/quickfix/createFromUsage/createVariable/property/beforeValOnUserTypeWithTypeParams.kt

@@ -0,0 +1,8 @@
+// "Create property 'foo' from usage" "true"
+// ERROR: Property must be initialized or be abstract
+
+class A<T>(val n: T)
+
+fun test<U>(u: U) {
+    val a: A<U> = A(u).<caret>foo
+}