Quick-fix for DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE added #KT-15966 Fixed

Author: mglukhikh

idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt

@@ -38,11 +38,13 @@ import org.jetbrains.kotlin.renderer.*
 import org.jetbrains.kotlin.resolve.descriptorUtil.setSingleOverridden
 
 interface OverrideMemberChooserObject : ClassMember {
-    enum class BodyType {
-        NO_BODY,
-        EMPTY,
-        SUPER,
-        QUALIFIED_SUPER
+    sealed class BodyType {
+        object NO_BODY : BodyType()
+        object EMPTY : BodyType()
+        object SUPER : BodyType()
+        object QUALIFIED_SUPER : BodyType()
+
+        class Delegate(val receiverName: String) : BodyType()
     }
 
     val descriptor: CallableMemberDescriptor
@@ -191,10 +193,15 @@ fun generateUnsupportedOrSuperCall(
     }
     else {
         return buildString {
-            append("super")
-            if (bodyType == OverrideMemberChooserObject.BodyType.QUALIFIED_SUPER) {
-                val superClassFqName = IdeDescriptorRenderers.SOURCE_CODE.renderClassifierName(descriptor.containingDeclaration as ClassifierDescriptor)
-                append("<").append(superClassFqName).append(">")
+            if (bodyType is OverrideMemberChooserObject.BodyType.Delegate) {
+                append(bodyType.receiverName)
+            }
+            else {
+                append("super")
+                if (bodyType == OverrideMemberChooserObject.BodyType.QUALIFIED_SUPER) {
+                    val superClassFqName = IdeDescriptorRenderers.SOURCE_CODE.renderClassifierName(descriptor.containingDeclaration as ClassifierDescriptor)
+                    append("<").append(superClassFqName).append(">")
+                }
             }
             append(".").append(descriptor.name.render())
 

idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt

@@ -429,6 +429,7 @@ class QuickFixRegistrar : QuickFixContributor {
         USAGE_IS_NOT_INLINABLE.registerFactory(AddInlineModifierFix.NoInlineFactory)
 
         UNRESOLVED_REFERENCE.registerFactory(MakeConstructorParameterPropertyFix)
+        DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE.registerFactory(SpecifyOverrideExplicitlyFix)
 
         SUPERTYPE_IS_EXTENSION_FUNCTION_TYPE.registerFactory(ConvertExtensionToFunctionTypeFix)
 

idea/src/org/jetbrains/kotlin/idea/quickfix/SpecifyOverrideExplicitlyFix.kt

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.quickfix
+
+import com.intellij.codeInsight.intention.IntentionAction
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.idea.caches.resolve.analyzeFullyAndGetResult
+import org.jetbrains.kotlin.idea.core.ShortenReferences
+import org.jetbrains.kotlin.idea.core.overrideImplement.OverrideMemberChooserObject
+import org.jetbrains.kotlin.idea.core.overrideImplement.generateMember
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+
+class SpecifyOverrideExplicitlyFix(
+        element: KtClassOrObject, private val signature: String
+) : KotlinQuickFixAction<KtClassOrObject>(element) {
+
+    override fun getText() = "Specify override for '$signature' explicitly"
+
+    override fun getFamilyName() = "Specify override explicitly"
+
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+        val element = element ?: return
+        val context = element.analyzeFullyAndGetResult().bindingContext
+        val delegatedDescriptor = context.diagnostics.forElement(element).mapNotNull {
+            if (it.factory == Errors.DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE)
+                Errors.DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE.cast(it).a
+            else
+                null
+        }.firstOrNull {
+            DescriptorRenderer.ONLY_NAMES_WITH_SHORT_TYPES.render(it) == signature
+        } ?: return
+        for (specifier in element.superTypeListEntries) {
+            if (specifier is KtDelegatedSuperTypeEntry) {
+                val superType = specifier.typeReference?.let { context[BindingContext.TYPE, it] } ?: continue
+                val superTypeDescriptor = superType.constructor.declarationDescriptor as? ClassDescriptor ?: continue
+                val overriddenDescriptor = delegatedDescriptor.overriddenDescriptors.find {
+                    it.containingDeclaration == superTypeDescriptor
+                } ?: continue
+
+                val delegateExpression = specifier.delegateExpression as? KtNameReferenceExpression
+                val delegateTargetDescriptor = context[BindingContext.REFERENCE_TARGET, delegateExpression] ?: return
+                if (delegateTargetDescriptor is ValueParameterDescriptor &&
+                    delegateTargetDescriptor.containingDeclaration.let {
+                        it is ConstructorDescriptor &&
+                        it.isPrimary &&
+                        it.containingDeclaration == delegatedDescriptor.containingDeclaration
+                    }) {
+                    val delegateParameter = DescriptorToSourceUtils.descriptorToDeclaration(
+                            delegateTargetDescriptor) as? KtParameter
+                    if (delegateParameter != null && !delegateParameter.hasValOrVar()) {
+                        val factory = KtPsiFactory(project)
+                        delegateParameter.addModifier(KtTokens.PRIVATE_KEYWORD)
+                        delegateParameter.addAfter(factory.createValKeyword(), delegateParameter.modifierList)
+                    }
+                }
+
+                val overrideMemberChooserObject = OverrideMemberChooserObject.create(
+                        project, delegatedDescriptor, overriddenDescriptor,
+                        OverrideMemberChooserObject.BodyType.Delegate(delegateTargetDescriptor.name.asString())
+                )
+                val member = overrideMemberChooserObject.generateMember(project, copyDoc = false)
+                val insertedMember = element.addDeclaration(member)
+                ShortenReferences.DEFAULT.process(insertedMember)
+                return
+            }
+        }
+
+    }
+
+    companion object : KotlinSingleIntentionActionFactory() {
+        override fun createAction(diagnostic: Diagnostic): IntentionAction? {
+            val hidesOverrideError = Errors.DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE.cast(diagnostic)
+            val klass = hidesOverrideError.psiElement
+            if (klass.superTypeListEntries.any {
+                it is KtDelegatedSuperTypeEntry && it.delegateExpression !is KtNameReferenceExpression
+            }) {
+                return null
+            }
+            val properOverride = hidesOverrideError.a
+            return SpecifyOverrideExplicitlyFix(klass, DescriptorRenderer.ONLY_NAMES_WITH_SHORT_TYPES.render(properOverride))
+        }
+    }
+}

idea/testData/quickfix/specifyOverrideExplicitly/base.kt

@@ -0,0 +1,11 @@
+// "Specify override for 'foo(): Unit' explicitly" "true"
+
+interface A {
+    fun foo()
+}
+
+open class B : A {
+    override fun foo() {}
+}
+
+class C<caret>(a: A) : B(), A by a

idea/testData/quickfix/specifyOverrideExplicitly/base.kt.after

@@ -0,0 +1,15 @@
+// "Specify override for 'foo(): Unit' explicitly" "true"
+
+interface A {
+    fun foo()
+}
+
+open class B : A {
+    override fun foo() {}
+}
+
+class C(private val a: A) : B(), A by a {
+    override fun foo() {
+        a.foo()
+    }
+}

idea/testData/quickfix/specifyOverrideExplicitly/global.kt

@@ -0,0 +1,15 @@
+// "Specify override for 'foo(): Unit' explicitly" "true"
+
+interface A {
+    fun foo()
+}
+
+open class B : A {
+    override fun foo() {}
+}
+
+fun bar(): A = null!!
+
+val a: A = bar()
+
+class C<caret>() : B(), A by a

idea/testData/quickfix/specifyOverrideExplicitly/global.kt.after

@@ -0,0 +1,19 @@
+// "Specify override for 'foo(): Unit' explicitly" "true"
+
+interface A {
+    fun foo()
+}
+
+open class B : A {
+    override fun foo() {}
+}
+
+fun bar(): A = null!!
+
+val a: A = bar()
+
+class C() : B(), A by a {
+    override fun foo() {
+        a.foo()
+    }
+}

idea/testData/quickfix/specifyOverrideExplicitly/lists.kt

@@ -0,0 +1,6 @@
+// "Specify override for 'isEmpty(): Boolean' explicitly" "true"
+// WITH_RUNTIME
+
+import java.util.*
+
+class <caret>B(f: MutableList<String>): ArrayList<String>(), MutableList<String> by f

idea/testData/quickfix/specifyOverrideExplicitly/lists.kt.after

@@ -0,0 +1,10 @@
+// "Specify override for 'isEmpty(): Boolean' explicitly" "true"
+// WITH_RUNTIME
+
+import java.util.*
+
+class B(private val f: MutableList<String>): ArrayList<String>(), MutableList<String> by f {
+    override fun isEmpty(): Boolean {
+        return f.isEmpty()
+    }
+}

idea/testData/quickfix/specifyOverrideExplicitly/lists2.kt

@@ -0,0 +1,10 @@
+// "Specify override for 'size: Int' explicitly" "true"
+// WITH_RUNTIME
+
+import java.util.*
+
+class <caret>B(private val f: MutableList<String>): ArrayList<String>(), MutableList<String> by f {
+    override fun isEmpty(): Boolean {
+        return f.isEmpty()
+    }
+}

idea/testData/quickfix/specifyOverrideExplicitly/lists2.kt.after

@@ -0,0 +1,13 @@
+// "Specify override for 'size: Int' explicitly" "true"
+// WITH_RUNTIME
+
+import java.util.*
+
+class B(private val f: MutableList<String>): ArrayList<String>(), MutableList<String> by f {
+    override fun isEmpty(): Boolean {
+        return f.isEmpty()
+    }
+
+    override val size: Int
+        get() = f.size
+}

idea/testData/quickfix/specifyOverrideExplicitly/notPossible.kt

@@ -0,0 +1,19 @@
+// "Specify override for 'foo(): Unit' explicitly" "false"
+// ACTION: Convert to secondary constructor
+// ACTION: Create test
+// ACTION: Make primary constructor internal
+// ACTION: Make primary constructor private
+// ACTION: Move 'C' to separate file
+// ACTION: Rename file to C.kt
+
+interface A {
+    fun foo()
+}
+
+class W(val a: A)
+
+open class B : A {
+    override fun foo() {}
+}
+
+class C<caret>(w: W) : B(), A by w.a

idea/testData/quickfix/specifyOverrideExplicitly/outer.kt

@@ -0,0 +1,13 @@
+// "Specify override for 'foo(): Unit' explicitly" "true"
+
+interface A {
+    fun foo()
+}
+
+open class B : A {
+    override fun foo() {}
+}
+
+fun bar(a: A) {
+    class C<caret> : B(), A by a
+}

idea/testData/quickfix/specifyOverrideExplicitly/outer.kt.after

@@ -0,0 +1,17 @@
+// "Specify override for 'foo(): Unit' explicitly" "true"
+
+interface A {
+    fun foo()
+}
+
+open class B : A {
+    override fun foo() {}
+}
+
+fun bar(a: A) {
+    class C : B(), A by a {
+        override fun foo() {
+            a.foo()
+        }
+    }
+}

idea/testData/quickfix/specifyOverrideExplicitly/property.kt

@@ -0,0 +1,11 @@
+// "Specify override for 'foo(): Unit' explicitly" "true"
+
+interface A {
+    fun foo()
+}
+
+open class B : A {
+    override fun foo() {}
+}
+
+class C<caret>(val a: A) : B(), A by a

idea/testData/quickfix/specifyOverrideExplicitly/property.kt.after

@@ -0,0 +1,15 @@
+// "Specify override for 'foo(): Unit' explicitly" "true"
+
+interface A {
+    fun foo()
+}
+
+open class B : A {
+    override fun foo() {}
+}
+
+class C(val a: A) : B(), A by a {
+    override fun foo() {
+        a.foo()
+    }
+}