Create subclass intention implemented #KT-8473 Fixed

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

compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiFactory.kt

@@ -427,6 +427,99 @@ class KtPsiFactory(private val project: Project) {
         return createClass("class A { constructor()$colonOrEmpty$text {}").getSecondaryConstructors().first().getDelegationCall()
     }
 
+    class ClassHeaderBuilder {
+
+        enum class State {
+            MODIFIERS,
+            NAME,
+            TYPE_PARAMETERS,
+            BASE_CLASS,
+            TYPE_CONSTRAINTS,
+            DONE
+        }
+        private val sb = StringBuilder()
+        private var state = State.MODIFIERS
+
+        fun modifier(modifier: String): ClassHeaderBuilder {
+            assert(state == State.MODIFIERS)
+
+            sb.append(modifier)
+
+            return this
+        }
+
+        private fun placeKeyword() {
+            assert(state == State.MODIFIERS)
+
+            if (sb.length != 0) {
+                sb.append(" ")
+            }
+            sb.append("class ")
+
+            state = State.NAME
+        }
+
+
+        fun name(name: String): ClassHeaderBuilder {
+            placeKeyword()
+
+            sb.append(name)
+            state = State.TYPE_PARAMETERS
+
+            return this
+        }
+
+        private fun appendInAngleBrackets(values: Collection<String>) {
+            if (values.isNotEmpty()) {
+                sb.append(values.joinToString(", ", "<", ">"))
+            }
+        }
+
+        fun typeParameters(values: Collection<String>): ClassHeaderBuilder {
+            assert(state == State.TYPE_PARAMETERS)
+
+            appendInAngleBrackets(values)
+            state = State.BASE_CLASS
+
+            return this
+        }
+
+        fun baseClass(name: String, typeArguments: Collection<String>, isInterface: Boolean): ClassHeaderBuilder {
+            assert(state == State.BASE_CLASS)
+
+            sb.append(" : $name")
+            appendInAngleBrackets(typeArguments)
+            if (!isInterface) {
+                sb.append("()")
+            }
+
+            state = State.TYPE_CONSTRAINTS
+
+            return this
+        }
+
+        fun typeConstraints(values: Collection<String>): ClassHeaderBuilder {
+            assert(state == State.TYPE_CONSTRAINTS)
+
+            if (!values.isEmpty()) {
+                sb.append(values.joinToString(", ", " where ", "", -1, ""))
+            }
+            state = State.DONE
+
+            return this
+        }
+
+        fun transform(f: StringBuilder.() -> Unit) = sb.f()
+
+        fun asString(): String {
+            if (state != State.DONE) {
+                state = State.DONE
+            }
+
+            return sb.toString()
+        }
+    }
+
     class CallableBuilder(private val target: Target) {
         enum class Target {
             FUNCTION,

compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/ktPsiUtil.kt

@@ -345,6 +345,8 @@ fun PsiElement.parameterIndex(): Int {
 
 fun KtModifierListOwner.isPrivate(): Boolean = hasModifier(KtTokens.PRIVATE_KEYWORD)
 
+fun KtModifierListOwner.isProtected(): Boolean = hasModifier(KtTokens.PROTECTED_KEYWORD)
+
 fun KtSimpleNameExpression.isImportDirectiveExpression(): Boolean {
     val parent = parent
     return parent is KtImportDirective || parent?.parent is KtImportDirective