From cc730c36adde7ce4bf78f5e57d169a71a12efce1 Mon Sep 17 00:00:00 2001 From: Kirill Rakhman Date: Mon, 21 Mar 2016 00:28:06 +0100 Subject: [PATCH] Implement quickfix to remove '.java' when KClass is expected Fixes #KT-11078 --- .../idea/quickfix/ConvertClassToKClassFix.kt | 82 +++++++++++++++++++ .../kotlin/idea/quickfix/QuickFixRegistrar.kt | 2 + .../convertClassToKClass1Runtime.kt | 9 ++ .../convertClassToKClass1Runtime.kt.after | 9 ++ .../idea/quickfix/QuickFixTestGenerated.java | 15 ++++ 5 files changed, 117 insertions(+) create mode 100644 idea/src/org/jetbrains/kotlin/idea/quickfix/ConvertClassToKClassFix.kt create mode 100644 idea/testData/quickfix/typeInferenceExpectedTypeMismatch/convertClassToKClass1Runtime.kt create mode 100644 idea/testData/quickfix/typeInferenceExpectedTypeMismatch/convertClassToKClass1Runtime.kt.after diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ConvertClassToKClassFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ConvertClassToKClassFix.kt new file mode 100644 index 00000000000..ee634bda1da --- /dev/null +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ConvertClassToKClassFix.kt @@ -0,0 +1,82 @@ +/* + * Copyright 2010-2016 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 com.intellij.psi.PsiFile +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.diagnostics.Diagnostic +import org.jetbrains.kotlin.diagnostics.Errors +import org.jetbrains.kotlin.idea.caches.resolve.analyze +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.psi.KtDotQualifiedExpression +import org.jetbrains.kotlin.psi.KtExpression +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.psiUtil.endOffset +import org.jetbrains.kotlin.psi.psiUtil.startOffset +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe +import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf + +private val JAVA_LANG_CLASS_FQ_NAME = FqName("java.lang.Class") + +private fun KotlinType.isJClass(): Boolean { + val expressionTypeFqName = constructor.declarationDescriptor?.fqNameSafe ?: return false + return expressionTypeFqName == JAVA_LANG_CLASS_FQ_NAME +} + +class ConvertClassToKClassFix(element: KtDotQualifiedExpression, private val type: KotlinType) : KotlinQuickFixAction(element) { + override fun getText() = "Remove '.${element.children.lastOrNull()?.text}'" + override fun getFamilyName() = "Remove conversion from 'KClass' to 'Class'" + + + override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean { + if (!super.isAvailable(project, editor, file)) return false + + val expressionType = element.analyze(BodyResolveMode.PARTIAL).getType(element) ?: return false + if (!expressionType.isJClass()) return false + + val children = element.children + if (children.size != 2) return false + + val firstChild = children.first() as? KtExpression ?: return false + val firstChildType = firstChild.analyze(BodyResolveMode.PARTIAL).getType(firstChild) ?: return false + + return firstChildType.isSubtypeOf(type) + } + + override fun invoke(project: Project, editor: Editor?, file: KtFile) { + val lastChild = element.children.lastOrNull() ?: return + editor?.document?.replaceString(lastChild.startOffset - 1, lastChild.endOffset, "") + } + + object Factory : KotlinIntentionActionsFactory() { + override fun doCreateActions(diagnostic: Diagnostic): List { + val casted = Errors.TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH.cast(diagnostic) + + val expectedClassDescriptor = casted.a.constructor.declarationDescriptor as? ClassDescriptor ?: return emptyList() + if (!KotlinBuiltIns.isKClass(expectedClassDescriptor)) return emptyList() + + val element = casted.psiElement.parent as? KtDotQualifiedExpression ?: return emptyList() + return listOf(ConvertClassToKClassFix(element, casted.a)) + } + } +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt index 582e534de08..297c4716485 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt @@ -338,6 +338,8 @@ class QuickFixRegistrar : QuickFixContributor { UPPER_BOUND_VIOLATED.registerFactory(AddGenericUpperBoundFix.Factory) TYPE_INFERENCE_UPPER_BOUND_VIOLATED.registerFactory(AddGenericUpperBoundFix.Factory) + TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH.registerFactory(ConvertClassToKClassFix.Factory) + NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION.registerFactory(ConstFixFactory) OPERATOR_MODIFIER_REQUIRED.registerFactory(AddModifierFixFactory(KtTokens.OPERATOR_KEYWORD)) diff --git a/idea/testData/quickfix/typeInferenceExpectedTypeMismatch/convertClassToKClass1Runtime.kt b/idea/testData/quickfix/typeInferenceExpectedTypeMismatch/convertClassToKClass1Runtime.kt new file mode 100644 index 00000000000..fb86a568d46 --- /dev/null +++ b/idea/testData/quickfix/typeInferenceExpectedTypeMismatch/convertClassToKClass1Runtime.kt @@ -0,0 +1,9 @@ +// "Remove '.java'" "true" +fun foo() { + bar(Foo::class.java) +} + +class Foo + +fun bar(kc: kotlin.reflect.KClass) { +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeInferenceExpectedTypeMismatch/convertClassToKClass1Runtime.kt.after b/idea/testData/quickfix/typeInferenceExpectedTypeMismatch/convertClassToKClass1Runtime.kt.after new file mode 100644 index 00000000000..0aa61c2cc42 --- /dev/null +++ b/idea/testData/quickfix/typeInferenceExpectedTypeMismatch/convertClassToKClass1Runtime.kt.after @@ -0,0 +1,9 @@ +// "Remove '.java'" "true" +fun foo() { + bar(Foo::class) +} + +class Foo + +fun bar(kc: kotlin.reflect.KClass) { +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java index 9437570c826..e9f99e956dc 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java @@ -7097,6 +7097,21 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } } + @TestMetadata("idea/testData/quickfix/typeInferenceExpectedTypeMismatch") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeInferenceExpectedTypeMismatch extends AbstractQuickFixTest { + public void testAllFilesPresentInTypeInferenceExpectedTypeMismatch() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/quickfix/typeInferenceExpectedTypeMismatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), true); + } + + @TestMetadata("convertClassToKClass1Runtime.kt") + public void testConvertClassToKClass1Runtime() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/typeInferenceExpectedTypeMismatch/convertClassToKClass1Runtime.kt"); + doTest(fileName); + } + } + @TestMetadata("idea/testData/quickfix/typeMismatch") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)