diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties index 7e072039840..f142c7c9ea0 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties +++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties @@ -52,6 +52,10 @@ rename.parameter.to.match.overridden.method=Rename parameter to match overridden rename.family=Rename add.semicolon.after.invocation=Add semicolon after invocation of ''{0}'' add.semicolon.family=Add Semicolon +change.return.type.to.match.overridden.method=Change return type to ''{0}'' +remove.return.type.to.match.overridden.method=Remove explicitly specified return type to match overridden method +change.property.type.to.match.overridden.property=Change property type to ''{0}'' +change.type.family=Change Type add.kotlin.signature.action.family.name=Specify Custom Kotlin Signature add.kotlin.signature.action.text=Specify custom Kotlin signature diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangePropertyTypeToMatchOverriddenPropertyFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangePropertyTypeToMatchOverriddenPropertyFix.java new file mode 100644 index 00000000000..e3d9c8e54eb --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangePropertyTypeToMatchOverriddenPropertyFix.java @@ -0,0 +1,90 @@ +/* + * Copyright 2010-2013 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.jet.plugin.quickfix; + +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiFile; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.psi.JetProperty; +import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.psi.JetTypeReference; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.plugin.JetBundle; +import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager; +import org.jetbrains.jet.plugin.intentions.SpecifyTypeExplicitlyAction; + +public class ChangePropertyTypeToMatchOverriddenPropertyFix extends JetIntentionAction { + private JetType matchingType; + + public ChangePropertyTypeToMatchOverriddenPropertyFix(@NotNull JetProperty property) { + super(property); + } + + @Override + public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { + if (!super.isAvailable(project, editor, file)) { + return false; + } + + BindingContext context = KotlinCacheManager.getInstance(project).getDeclarationsFromProject().getBindingContext(); + matchingType = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(context, element); + return matchingType != null; + } + + @NotNull + @Override + public String getText() { + return JetBundle.message("change.property.type.to.match.overridden.property", matchingType); + } + + @NotNull + @Override + public String getFamilyName() { + return JetBundle.message("change.type.family"); + } + + @Override + public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { + JetTypeReference typeReference = element.getTypeRef(); + if (typeReference == null) { + SpecifyTypeExplicitlyAction.addTypeAnnotation(project, editor, element, matchingType); + } + else { + PsiElement newType = JetPsiFactory.createType(project, matchingType.toString()); + typeReference.replace(newType); + } + } + + @NotNull + public static JetIntentionActionFactory createFactory() { + return new JetIntentionActionFactory() { + @Nullable + @Override + public IntentionAction createAction(Diagnostic diagnostic) { + JetProperty property = QuickFixUtil.getParentElementOfType(diagnostic, JetProperty.class); + return property == null ? null : new ChangePropertyTypeToMatchOverriddenPropertyFix(property); + } + }; + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeReturnTypeToMatchOverriddenMethodFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeReturnTypeToMatchOverriddenMethodFix.java new file mode 100644 index 00000000000..64e1217170f --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeReturnTypeToMatchOverriddenMethodFix.java @@ -0,0 +1,101 @@ +/* + * Copyright 2010-2013 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.jet.plugin.quickfix; + +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiFile; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.psi.JetFunction; +import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.psi.JetTypeReference; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import org.jetbrains.jet.plugin.JetBundle; +import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager; +import org.jetbrains.jet.plugin.intentions.SpecifyTypeExplicitlyAction; + +public class ChangeReturnTypeToMatchOverriddenMethodFix extends JetIntentionAction { + private JetType matchingReturnType; + + public ChangeReturnTypeToMatchOverriddenMethodFix(@NotNull JetFunction function) { + super(function); + } + + @Override + public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { + if (!super.isAvailable(project, editor, file)) { + return false; + } + + BindingContext context = KotlinCacheManager.getInstance(project).getDeclarationsFromProject().getBindingContext(); + matchingReturnType = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(context, element); + return matchingReturnType != null; + } + + @NotNull + @Override + public String getText() { + if (KotlinBuiltIns.getInstance().isUnit(matchingReturnType)) { + return JetBundle.message("remove.return.type.to.match.overridden.method"); + } + else { + return JetBundle.message("change.return.type.to.match.overridden.method", matchingReturnType); + } + } + + @NotNull + @Override + public String getFamilyName() { + return JetBundle.message("change.type.family"); + } + + @Override + public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { + if (KotlinBuiltIns.getInstance().isUnit(matchingReturnType)) { + SpecifyTypeExplicitlyAction.removeTypeAnnotation(element); + } + else { + JetTypeReference returnTypeReference = element.getReturnTypeRef(); + if (returnTypeReference == null) { + SpecifyTypeExplicitlyAction.addTypeAnnotation(project, editor, element, matchingReturnType); + } + else { + PsiElement newReturnType = JetPsiFactory.createType(project, matchingReturnType.toString()); + returnTypeReference.replace(newReturnType); + } + } + } + + @NotNull + public static JetIntentionActionFactory createFactory() { + return new JetIntentionActionFactory() { + @Nullable + @Override + public IntentionAction createAction(Diagnostic diagnostic) { + JetFunction function = QuickFixUtil.getParentElementOfType(diagnostic, JetFunction.class); + return function == null ? null : new ChangeReturnTypeToMatchOverriddenMethodFix(function); + } + }; + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java index 91c6eaca24d..c645d557866 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java @@ -25,11 +25,13 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamedDeclaration; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.types.DeferredType; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import static org.jetbrains.jet.plugin.project.AnalyzeSingleFileUtil.getContextForSingleFile; @@ -63,4 +65,27 @@ public class QuickFixUtil { } return type; } + + @Nullable + public static JetType findLowerBoundOfOverriddenCallablesReturnTypes(BindingContext context, JetDeclaration callable) { + DeclarationDescriptor descriptor = context.get(BindingContext.DECLARATION_TO_DESCRIPTOR, callable); + if (!(descriptor instanceof CallableDescriptor)) { + return null; + } + + JetType matchingReturnType = null; + for (CallableDescriptor overriddenDescriptor : ((CallableDescriptor) descriptor).getOverriddenDescriptors()) { + JetType overriddenReturnType = overriddenDescriptor.getReturnType(); + if (overriddenReturnType == null) { + return null; + } + if (matchingReturnType == null || JetTypeChecker.INSTANCE.isSubtypeOf(overriddenReturnType, matchingReturnType)) { + matchingReturnType = overriddenReturnType; + } + else if (!JetTypeChecker.INSTANCE.isSubtypeOf(matchingReturnType, overriddenReturnType)) { + return null; + } + } + return matchingReturnType; + } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java index cf8a035b83c..09f78be64f2 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java @@ -202,5 +202,8 @@ public class QuickFixes { factories.put(NOT_AN_ANNOTATION_CLASS, MakeClassAnAnnotationClassFix.createFactory()); factories.put(DANGLING_FUNCTION_LITERAL_ARGUMENT_SUSPECTED, AddSemicolonAfterFunctionCallFix.createFactory()); + + factories.put(RETURN_TYPE_MISMATCH_ON_OVERRIDE, ChangeReturnTypeToMatchOverriddenMethodFix.createFactory()); + factories.put(PROPERTY_TYPE_MISMATCH_ON_OVERRIDE, ChangePropertyTypeToMatchOverriddenPropertyFix.createFactory()); } } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntLong.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntLong.kt new file mode 100644 index 00000000000..2ea365e2cad --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntLong.kt @@ -0,0 +1,8 @@ +// "Change property type to 'Int'" "true" +abstract class A { + abstract var x : Int +} + +abstract class B : A() { + override abstract var x : Int +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntUnit.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntUnit.kt new file mode 100644 index 00000000000..fb5aa1327f4 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntUnit.kt @@ -0,0 +1,8 @@ +// "Change property type to 'Int'" "true" +abstract class A { + abstract var x : Int +} + +abstract class B : A() { + override abstract var x: Int +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnMultipleOverride.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnMultipleOverride.kt new file mode 100644 index 00000000000..fc23fe09d3c --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnMultipleOverride.kt @@ -0,0 +1,15 @@ +// "Change return type to 'T'" "true" +open class S {} +open class T : S() {} + +abstract class A { + abstract fun foo() : S; +} + +trait X { + fun foo() : T; +} + +abstract class B : A(), X { + override abstract fun foo() : T; +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnOverrideIntLong.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnOverrideIntLong.kt new file mode 100644 index 00000000000..4a1a153b6b1 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnOverrideIntLong.kt @@ -0,0 +1,8 @@ +// "Change return type to 'Int'" "true" +abstract class A { + abstract fun foo() : Int; +} + +abstract class B : A() { + abstract override fun foo() : Int; +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnOverrideIntUnit.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnOverrideIntUnit.kt new file mode 100644 index 00000000000..8a1af1e423a --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnOverrideIntUnit.kt @@ -0,0 +1,8 @@ +// "Change return type to 'Int'" "true" +abstract class A { + abstract fun foo() : Int; +} + +abstract class B : A() { + abstract override fun foo(): Int; +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnOverrideUnitInt.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnOverrideUnitInt.kt new file mode 100644 index 00000000000..7cd9bbe922e --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterReturnTypeMismatchOnOverrideUnitInt.kt @@ -0,0 +1,4 @@ +// "Remove explicitly specified return type to match overridden method" "true" +abstract class A : java.util.Iterator { + public abstract override fun remove(); +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntLong.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntLong.kt new file mode 100644 index 00000000000..1cffc8dcfaa --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntLong.kt @@ -0,0 +1,8 @@ +// "Change property type to 'Int'" "true" +abstract class A { + abstract var x : Int +} + +abstract class B : A() { + override abstract var x : Long +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntUnit.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntUnit.kt new file mode 100644 index 00000000000..542a4f203e4 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntUnit.kt @@ -0,0 +1,8 @@ +// "Change property type to 'Int'" "true" +abstract class A { + abstract var x : Int +} + +abstract class B : A() { + override abstract var x +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnMultipleOverride.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnMultipleOverride.kt new file mode 100644 index 00000000000..5f932fcf981 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnMultipleOverride.kt @@ -0,0 +1,15 @@ +// "Change return type to 'T'" "true" +open class S {} +open class T : S() {} + +abstract class A { + abstract fun foo() : S; +} + +trait X { + fun foo() : T; +} + +abstract class B : A(), X { + override abstract fun foo() : Int; +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnMultipleOverrideAmbiguity.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnMultipleOverrideAmbiguity.kt new file mode 100644 index 00000000000..a11b75f863e --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnMultipleOverrideAmbiguity.kt @@ -0,0 +1,15 @@ +// "Change return type to 'Int'" "false" +// "Change return type to 'Long'" "false" +// "Remove explicitly specified return type to match overridden method" "false" +// ERROR: Return type is 'jet.String', which is not a subtype of overridden
internal abstract fun foo() : jet.Int defined in A +abstract class A { + abstract fun foo() : Int; +} + +trait X { + fun foo() : Long; +} + +abstract class B : A(), X { + abstract override fun foo() : String; +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideIntLong.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideIntLong.kt new file mode 100644 index 00000000000..7b3ca9bcdf7 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideIntLong.kt @@ -0,0 +1,8 @@ +// "Change return type to 'Int'" "true" +abstract class A { + abstract fun foo() : Int; +} + +abstract class B : A() { + abstract override fun foo() : Long; +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideIntUnit.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideIntUnit.kt new file mode 100644 index 00000000000..f0aa7b8f576 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideIntUnit.kt @@ -0,0 +1,8 @@ +// "Change return type to 'Int'" "true" +abstract class A { + abstract fun foo() : Int; +} + +abstract class B : A() { + abstract override fun foo(); +} diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideUnitInt.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideUnitInt.kt new file mode 100644 index 00000000000..1201c693311 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideUnitInt.kt @@ -0,0 +1,4 @@ +// "Remove explicitly specified return type to match overridden method" "true" +abstract class A : java.util.Iterator { + public abstract override fun remove() : Int; +} diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixMultiFileTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixMultiFileTestGenerated.java index 4eea5d6553b..2f1c457f151 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixMultiFileTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixMultiFileTestGenerated.java @@ -31,7 +31,7 @@ import org.jetbrains.jet.plugin.quickfix.AbstractQuickFixMultiFileTest; /** This class is generated by {@link org.jetbrains.jet.generators.tests.GenerateTests}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @TestMetadata("idea/testData/quickfix") -@InnerTestClasses({QuickFixMultiFileTestGenerated.AddStarProjections.class, QuickFixMultiFileTestGenerated.AutoImports.class, QuickFixMultiFileTestGenerated.Modifiers.class, QuickFixMultiFileTestGenerated.Nullables.class, QuickFixMultiFileTestGenerated.TypeImports.class, QuickFixMultiFileTestGenerated.Variables.class}) +@InnerTestClasses({QuickFixMultiFileTestGenerated.AddStarProjections.class, QuickFixMultiFileTestGenerated.AutoImports.class, QuickFixMultiFileTestGenerated.Modifiers.class, QuickFixMultiFileTestGenerated.Nullables.class, QuickFixMultiFileTestGenerated.Override.class, QuickFixMultiFileTestGenerated.TypeImports.class, QuickFixMultiFileTestGenerated.Variables.class}) public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTest { public void testAllFilesPresentInQuickfix() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix"), Pattern.compile("^(\\w+)\\.before\\.Main\\.kt$"), true); @@ -192,6 +192,20 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } } + @TestMetadata("idea/testData/quickfix/override") + @InnerTestClasses({}) + public static class Override extends AbstractQuickFixMultiFileTest { + public void testAllFilesPresentInOverride() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/override"), Pattern.compile("^(\\w+)\\.before\\.Main\\.kt$"), true); + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("Override"); + suite.addTestSuite(Override.class); + return suite; + } + } + @TestMetadata("idea/testData/quickfix/typeImports") public static class TypeImports extends AbstractQuickFixMultiFileTest { public void testAllFilesPresentInTypeImports() throws Exception { @@ -226,6 +240,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes suite.addTestSuite(AutoImports.class); suite.addTest(Modifiers.innerSuite()); suite.addTest(Nullables.innerSuite()); + suite.addTest(Override.innerSuite()); suite.addTestSuite(TypeImports.class); suite.addTest(Variables.innerSuite()); return suite; diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 51d20a4fe68..625e3b13acc 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -695,6 +695,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } @TestMetadata("idea/testData/quickfix/override") + @InnerTestClasses({Override.TypeMismatchOnOverride.class}) public static class Override extends AbstractQuickFixTest { public void testAllFilesPresentInOverride() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/override"), Pattern.compile("^before(\\w+)\\.kt$"), true); @@ -730,6 +731,55 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/override/beforeVirtualMethodHidden.kt"); } + @TestMetadata("idea/testData/quickfix/override/typeMismatchOnOverride") + public static class TypeMismatchOnOverride extends AbstractQuickFixTest { + public void testAllFilesPresentInTypeMismatchOnOverride() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/override/typeMismatchOnOverride"), Pattern.compile("^before(\\w+)\\.kt$"), true); + } + + @TestMetadata("beforePropertyTypeMismatchOnOverrideIntLong.kt") + public void testPropertyTypeMismatchOnOverrideIntLong() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntLong.kt"); + } + + @TestMetadata("beforePropertyTypeMismatchOnOverrideIntUnit.kt") + public void testPropertyTypeMismatchOnOverrideIntUnit() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntUnit.kt"); + } + + @TestMetadata("beforeReturnTypeMismatchOnMultipleOverride.kt") + public void testReturnTypeMismatchOnMultipleOverride() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnMultipleOverride.kt"); + } + + @TestMetadata("beforeReturnTypeMismatchOnMultipleOverrideAmbiguity.kt") + public void testReturnTypeMismatchOnMultipleOverrideAmbiguity() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnMultipleOverrideAmbiguity.kt"); + } + + @TestMetadata("beforeReturnTypeMismatchOnOverrideIntLong.kt") + public void testReturnTypeMismatchOnOverrideIntLong() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideIntLong.kt"); + } + + @TestMetadata("beforeReturnTypeMismatchOnOverrideIntUnit.kt") + public void testReturnTypeMismatchOnOverrideIntUnit() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideIntUnit.kt"); + } + + @TestMetadata("beforeReturnTypeMismatchOnOverrideUnitInt.kt") + public void testReturnTypeMismatchOnOverrideUnitInt() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeReturnTypeMismatchOnOverrideUnitInt.kt"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("Override"); + suite.addTestSuite(Override.class); + suite.addTestSuite(TypeMismatchOnOverride.class); + return suite; + } } @TestMetadata("idea/testData/quickfix/supertypeInitialization") @@ -1056,7 +1106,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { suite.addTestSuite(Migration.class); suite.addTest(Modifiers.innerSuite()); suite.addTest(Nullables.innerSuite()); - suite.addTestSuite(Override.class); + suite.addTest(Override.innerSuite()); suite.addTestSuite(SupertypeInitialization.class); suite.addTestSuite(TypeAddition.class); suite.addTestSuite(TypeImports.class);