Create subclass intention implemented #KT-8473 Fixed

Can be used for implementing interfaces / abstract classes / sealed classes or extending open classes

idea/testData/quickfix/implement/abstract.kt

@@ -0,0 +1,8 @@
+// "Implement abstract class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+private abstract class <caret>Base {
+    abstract var x: Int
+
+    abstract fun toInt(arg: String): Int
+}

idea/testData/quickfix/implement/abstract.kt.after

@@ -0,0 +1,19 @@
+// "Implement abstract class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+private abstract class Base {
+    abstract var x: Int
+
+    abstract fun toInt(arg: String): Int
+}
+
+private class BaseImpl : Base() {
+    override var x: Int
+        get() = throw UnsupportedOperationException()
+        set(value) {
+        }
+
+    override fun toInt(arg: String): Int {
+        throw UnsupportedOperationException()
+    }
+}

idea/testData/quickfix/implement/annotation.kt

@@ -0,0 +1,4 @@
+// "Create subclass" "false"
+
+annotation class <caret>My(val x: Int)
+

idea/testData/quickfix/implement/enum.kt

@@ -0,0 +1,10 @@
+// "Create subclass" "false"
+// ACTION: Create test
+
+enum class <caret>My {
+    SINGLE {
+        override fun foo(): Int = 0
+    };
+
+    abstract fun foo(): Int
+}

idea/testData/quickfix/implement/finalClass.kt

@@ -0,0 +1,3 @@
+// "Create subclass" "false"
+
+class Base

idea/testData/quickfix/implement/inCompanion.kt

@@ -0,0 +1,8 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    companion object {
+        open class <caret>Base
+    }
+}

idea/testData/quickfix/implement/inCompanion.kt.after

@@ -0,0 +1,10 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    companion object {
+        open class Base
+    }
+}
+
+class BaseImpl : Container.Companion.Base()

idea/testData/quickfix/implement/inInternalCompanion.kt

@@ -0,0 +1,8 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    internal companion object {
+        open class <caret>Base
+    }
+}

idea/testData/quickfix/implement/inInternalCompanion.kt.after

@@ -0,0 +1,10 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    internal companion object {
+        open class Base
+    }
+}
+
+internal class BaseImpl : Container.Companion.Base()

idea/testData/quickfix/implement/inPrivateCompanion.kt

@@ -0,0 +1,8 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    private companion object {
+        open class <caret>Base
+    }
+}

idea/testData/quickfix/implement/inPrivateCompanion.kt.after

@@ -0,0 +1,10 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    private companion object {
+        open class Base
+    }
+
+    private class BaseImpl : Companion.Base()
+}

idea/testData/quickfix/implement/inProtectedCompanion.kt

@@ -0,0 +1,8 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    protected companion object {
+        open class <caret>Base
+    }
+}

idea/testData/quickfix/implement/inProtectedCompanion.kt.after

@@ -0,0 +1,10 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    protected companion object {
+        open class Base
+    }
+
+    protected class BaseImpl : Companion.Base()
+}

idea/testData/quickfix/implement/incorrectRange.kt

@@ -0,0 +1,7 @@
+// "Implement interface" "false"
+// ACTION: Convert function to property
+// ACTION: Convert member to extension
+
+interface Base {
+    fun <caret>foo(): Int
+}

idea/testData/quickfix/implement/inner.kt

@@ -0,0 +1,8 @@
+// "Implement abstract class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    inner abstract class <caret>Base {
+        abstract fun foo(): String
+    }
+}

idea/testData/quickfix/implement/inner.kt.after

@@ -0,0 +1,14 @@
+// "Implement abstract class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    inner abstract class Base {
+        abstract fun foo(): String
+    }
+
+    inner class BaseImpl : Base() {
+        override fun foo(): String {
+            throw UnsupportedOperationException()
+        }
+    }
+}

idea/testData/quickfix/implement/interface.kt

@@ -0,0 +1,8 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+interface <caret>Base {
+    fun foo(x: Int): Int
+
+    fun bar(y: String) = y
+}

idea/testData/quickfix/implement/interface.kt.after

@@ -0,0 +1,14 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+interface Base {
+    fun foo(x: Int): Int
+
+    fun bar(y: String) = y
+}
+
+class BaseImpl : Base {
+    override fun foo(x: Int): Int {
+        throw UnsupportedOperationException()
+    }
+}

idea/testData/quickfix/implement/local.kt

@@ -0,0 +1,8 @@
+// "Implement abstract class" "false"
+
+fun foo() {
+    abstract class <caret>My {
+        abstract fun bar(): Int
+    }
+}
+

idea/testData/quickfix/implement/nested.kt

@@ -0,0 +1,16 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    interface <caret>Base {
+        val x: Boolean
+
+        val y: Double
+            get() = 3.14
+
+        fun foo(): String = ""
+
+        fun bar(z: Int): String
+    }
+}
+

idea/testData/quickfix/implement/nested.kt.after

@@ -0,0 +1,25 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    interface Base {
+        val x: Boolean
+
+        val y: Double
+            get() = 3.14
+
+        fun foo(): String = ""
+
+        fun bar(z: Int): String
+    }
+}
+
+class BaseImpl : Container.Base {
+    override val x: Boolean
+        get() = throw UnsupportedOperationException()
+
+    override fun bar(z: Int): String {
+        throw UnsupportedOperationException()
+    }
+}
+

idea/testData/quickfix/implement/nestedPrivateInterface.kt

@@ -0,0 +1,8 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    private interface <caret>Base {
+        var z: Double
+    }
+}

idea/testData/quickfix/implement/nestedPrivateInterface.kt.after

@@ -0,0 +1,15 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    private interface Base {
+        var z: Double
+    }
+
+    class BaseImpl : Base {
+        override var z: Double
+            get() = throw UnsupportedOperationException()
+            set(value) {
+            }
+    }
+}

idea/testData/quickfix/implement/noDefaultConstructor.kt

@@ -0,0 +1,3 @@
+// "Implement abstract class" "false"
+
+abstract class Base(val x: Int)

idea/testData/quickfix/implement/private.kt

@@ -0,0 +1,4 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+private open class <caret>Base

idea/testData/quickfix/implement/private.kt.after

@@ -0,0 +1,5 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+private open class Base
+private class BaseImpl : Base()

idea/testData/quickfix/implement/privateConstructor.kt

@@ -0,0 +1,3 @@
+// "Implement abstract class" "false"
+
+abstract class Base private constructor

idea/testData/quickfix/implement/privateNested.kt

@@ -0,0 +1,10 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    private open class <caret>Base {
+        open var x: String = ""
+
+        open fun foo(): String = ""
+    }
+}

idea/testData/quickfix/implement/privateNested.kt.after

@@ -0,0 +1,12 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    private open class Base {
+        open var x: String = ""
+
+        open fun foo(): String = ""
+    }
+
+    private class BaseImpl : Base()
+}

idea/testData/quickfix/implement/privateNestedWithConflict.kt

@@ -0,0 +1,12 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    private open class <caret>Base {
+        open var x: String = ""
+
+        open fun foo(): String = ""
+    }
+
+    private class BaseImpl : Base()
+}

idea/testData/quickfix/implement/privateNestedWithConflict.kt.after

@@ -0,0 +1,14 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    private open class Base {
+        open var x: String = ""
+
+        open fun foo(): String = ""
+    }
+
+    private class BaseImpl1 : Base()
+
+    private class BaseImpl : Base()
+}

idea/testData/quickfix/implement/protected.kt

@@ -0,0 +1,6 @@
+// "Implement abstract class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    protected abstract class <caret>Base
+}

idea/testData/quickfix/implement/protected.kt.after

@@ -0,0 +1,7 @@
+// "Implement abstract class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+class Container {
+    protected abstract class Base
+    protected class BaseImpl : Base()
+}

idea/testData/quickfix/implement/sealed.kt

@@ -0,0 +1,6 @@
+// "Implement sealed class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+sealed class <caret>Base {
+    abstract fun foo(): Int
+}

idea/testData/quickfix/implement/sealed.kt.after

@@ -0,0 +1,11 @@
+// "Implement sealed class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+sealed class Base {
+    abstract fun foo(): Int
+    class BaseImpl : Base() {
+        override fun foo(): Int {
+            throw UnsupportedOperationException()
+        }
+    }
+}

idea/testData/quickfix/implement/sealedEmpty.kt

@@ -0,0 +1,4 @@
+// "Implement sealed class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+sealed class <caret>Sealed

idea/testData/quickfix/implement/sealedEmpty.kt.after

@@ -0,0 +1,6 @@
+// "Implement sealed class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+sealed class Sealed {
+    class SealedImpl : Sealed()
+}

idea/testData/quickfix/implement/sealedWithConflict.kt

@@ -0,0 +1,10 @@
+// "Implement sealed class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+sealed class <caret>Base {
+    abstract fun foo(): Int
+
+    class BaseImpl : Base() {
+        override fun foo() = throw UnsupportedOperationException()
+    }
+}

idea/testData/quickfix/implement/sealedWithConflict.kt.after

@@ -0,0 +1,16 @@
+// "Implement sealed class" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+sealed class Base {
+    abstract fun foo(): Int
+
+    class BaseImpl : Base() {
+        override fun foo() = throw UnsupportedOperationException()
+    }
+
+    class BaseImpl1 : Base() {
+        override fun foo(): Int {
+            throw UnsupportedOperationException()
+        }
+    }
+}

idea/testData/quickfix/implement/typeParameter.kt

@@ -0,0 +1,4 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+interface <caret>Base<T : Any>

idea/testData/quickfix/implement/typeParameter.kt.after

@@ -0,0 +1,5 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+interface Base<T : Any>
+class BaseImpl<T : Any> : Base<T>

idea/testData/quickfix/implement/typeParameterOut.kt

@@ -0,0 +1,4 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+interface <caret>Base<out T>

idea/testData/quickfix/implement/typeParameterOut.kt.after

@@ -0,0 +1,5 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+interface Base<out T>
+class BaseImpl<out T> : Base<T>

idea/testData/quickfix/implement/typeParameterWhere.kt

@@ -0,0 +1,4 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+interface <caret>Base<T> where T : Any

idea/testData/quickfix/implement/typeParameterWhere.kt.after

@@ -0,0 +1,5 @@
+// "Implement interface" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+interface Base<T> where T : Any
+class BaseImpl<T> : Base<T> where T : Any

idea/testData/quickfix/implement/typeParametersClass.kt

@@ -0,0 +1,4 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+open class <caret>Base<T : Any, L : List<T>>

idea/testData/quickfix/implement/typeParametersClass.kt.after

@@ -0,0 +1,5 @@
+// "Create subclass" "true"
+// SHOULD_BE_AVAILABLE_AFTER_EXECUTION
+
+open class Base<T : Any, L : List<T>>
+class BaseImpl<T : Any, L : List<T>> : Base<T, L>()