From 27f76630e692d4d18ef558f168e0033cdf59ac10 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 5 Jun 2014 20:53:31 +0400 Subject: [PATCH] ACCIDENTAL_OVERRIDE diagnostics supported #KT-1 In Progress --- .../SignatureCollectingClassBuilderFactory.kt | 4 + .../jet/codegen/state/GenerationState.java | 114 ++++++++++++++++-- .../diagnostics/DefaultErrorMessagesJvm.java | 1 + .../resolve/java/diagnostics/ErrorsJvm.java | 1 + .../jet/asJava/duplicateJvmSignatureUtil.kt | 14 ++- compiler/testData/cli/jvm/signatureClash.kt | 8 +- compiler/testData/cli/jvm/signatureClash.out | 9 +- .../classFunctionOverriddenByProperty.kt | 2 +- ...nctionOverriddenByPropertyInConstructor.kt | 5 + ...assFunctionOverriddenByPropertyNoGetter.kt | 7 ++ .../classPropertyOverriddenByFunction.kt | 2 +- .../delegatedFunctionOverriddenByProperty.kt | 10 ++ .../genericClassFunction.kt | 9 ++ ...rivateClassFunctionOverriddenByProperty.kt | 8 ++ .../traitFunctionOverriddenByProperty.kt | 2 +- ...raitFunctionOverriddenByPropertyInTrait.kt | 8 ++ ...traitFunctionOverriddenByPropertyNoImpl.kt | 8 ++ ...raitPropertyOverriddenByFunctionInTrait.kt | 8 ++ ...traitPropertyOverriddenByFunctionNoImpl.kt | 7 ++ .../diagnostics/tests/override/Generics.kt | 2 +- .../checkers/JetDiagnosticsTestGenerated.java | 45 +++++++ idea/testData/checker/OverridesAndGenerics.kt | 2 +- 22 files changed, 251 insertions(+), 25 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyInTrait.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionInTrait.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/SignatureCollectingClassBuilderFactory.kt b/compiler/backend/src/org/jetbrains/jet/codegen/SignatureCollectingClassBuilderFactory.kt index abe23fbc8be..7b3e52dae3e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/SignatureCollectingClassBuilderFactory.kt +++ b/compiler/backend/src/org/jetbrains/jet/codegen/SignatureCollectingClassBuilderFactory.kt @@ -31,6 +31,7 @@ public abstract class SignatureCollectingClassBuilderFactory( ) : ClassBuilderFactory by delegate { protected abstract fun handleClashingSignatures(data: ConflictingJvmDeclarationsData) + protected abstract fun onClassDone(classOrigin: JvmDeclarationOrigin, classInternalName: String?, hasDuplicateSignatures: Boolean) override fun newClassBuilder(origin: JvmDeclarationOrigin): SignatureCollectingClassBuilder { return SignatureCollectingClassBuilder(origin, delegate.newClassBuilder(origin)) @@ -67,6 +68,7 @@ public abstract class SignatureCollectingClassBuilderFactory( } override fun done() { + var hasDuplicateSignatures = false for ((signature, elementsAndDescriptors) in signatures.entrySet()!!) { if (elementsAndDescriptors.size == 1) continue // no clash handleClashingSignatures(ConflictingJvmDeclarationsData( @@ -75,7 +77,9 @@ public abstract class SignatureCollectingClassBuilderFactory( signature, elementsAndDescriptors )) + hasDuplicateSignatures = true } + onClassDone(classCreatedFor, classInternalName, hasDuplicateSignatures) super.done() } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java index cb212173320..fa4d3a91eff 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.codegen.state; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; +import com.intellij.util.containers.MultiMap; import kotlin.Function1; import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; @@ -26,25 +27,23 @@ import org.jetbrains.jet.codegen.*; import org.jetbrains.jet.codegen.binding.CodegenBinding; import org.jetbrains.jet.codegen.inline.InlineCodegenUtil; import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder; import org.jetbrains.jet.lang.psi.JetClassOrObject; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.reflect.ReflectionTypes; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace; -import org.jetbrains.jet.lang.resolve.java.diagnostics.ConflictingJvmDeclarationsData; -import org.jetbrains.jet.lang.resolve.java.diagnostics.ErrorsJvm; -import org.jetbrains.jet.lang.resolve.java.diagnostics.JvmDeclarationOrigin; +import org.jetbrains.jet.lang.resolve.java.diagnostics.*; +import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodSignature; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.java.diagnostics.JvmDeclarationOriginKind; -import java.util.Collection; -import java.util.Collections; -import java.util.LinkedHashSet; -import java.util.List; +import java.util.*; + +import static org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.DELEGATION; +import static org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.FAKE_OVERRIDE; public class GenerationState { public interface GenerateClassFilter { @@ -275,7 +274,7 @@ public class GenerationState { return moduleId; } - private static class BuilderfactoryForDuplicateSignatureDiagnostics extends SignatureCollectingClassBuilderFactory { + private class BuilderfactoryForDuplicateSignatureDiagnostics extends SignatureCollectingClassBuilderFactory { private final DiagnosticHolder diagnostics; @@ -313,5 +312,98 @@ public class GenerationState { diagnostics.report(ErrorsJvm.CONFLICTING_JVM_DECLARATIONS.on(element, data)); } } + + @Override + protected void onClassDone( + @NotNull JvmDeclarationOrigin classOrigin, + @Nullable String classInternalName, + boolean hasDuplicateSignatures + ) { + DeclarationDescriptor descriptor = classOrigin.getDescriptor(); + if (!(descriptor instanceof ClassDescriptor)) return; + + ClassDescriptor classDescriptor = (ClassDescriptor) descriptor; + + MultiMap groupedBySignature = MultiMap.create(); + Queue queue = + new LinkedList(classDescriptor.getDefaultType().getMemberScope().getAllDescriptors()); + while (!queue.isEmpty()) { + DeclarationDescriptor member = queue.poll(); + if (member instanceof DeclarationDescriptorWithVisibility && + ((DeclarationDescriptorWithVisibility) member).getVisibility() == Visibilities.INVISIBLE_FAKE) { + // a member of super is not visible: no override + continue; + } + if (member instanceof PropertyDescriptor) { + PropertyDescriptor propertyDescriptor = (PropertyDescriptor) member; + + PropertyGetterDescriptor getter = propertyDescriptor.getGetter(); + if (getter != null) { + queue.add(getter); + } + PropertySetterDescriptor setter = propertyDescriptor.getSetter(); + if (setter != null) { + queue.add(setter); + } + } + else if (member instanceof FunctionDescriptor) { + FunctionDescriptor functionDescriptor = (FunctionDescriptor) member; + + JvmMethodSignature methodSignature = typeMapper.mapSignature(functionDescriptor); + RawSignature rawSignature = new RawSignature( + methodSignature.getAsmMethod().getName(), + methodSignature.getAsmMethod().getDescriptor(), + MemberKind.METHOD + ); + groupedBySignature.putValue(rawSignature, functionDescriptor); + } + } + + signatures: + for (Map.Entry> entry : groupedBySignature.entrySet()) { + RawSignature rawSignature = entry.getKey(); + Collection members = entry.getValue(); + + if (members.size() <= 1) continue; + + PsiElement memberElement = null; + int nonFakeCount = 0; + for (CallableMemberDescriptor member : members) { + // + if (member.getKind() != FAKE_OVERRIDE) { + nonFakeCount++; + // If there's more than one real element, the clashing signature is already reported. + // Only clashes between fake overrides are interesting here + if (nonFakeCount > 1) continue signatures; + + if (member.getKind() != DELEGATION) { + // Delegates don't have declarations in the code + memberElement = BindingContextUtils.callableDescriptorToDeclaration(getBindingContext(), member); + if (memberElement == null && member instanceof PropertyAccessorDescriptor) { + memberElement = BindingContextUtils.callableDescriptorToDeclaration( + getBindingContext(), + ((PropertyAccessorDescriptor) member).getCorrespondingProperty() + ); + } + } + } + } + + PsiElement elementToReportOn = memberElement == null ? classOrigin.getElement() : memberElement; + if (elementToReportOn == null) return; + + List origins = KotlinPackage.map( + members, + new Function1() { + @Override + public JvmDeclarationOrigin invoke(CallableMemberDescriptor descriptor) { + return DiagnosticsPackage.OtherOrigin(descriptor); + } + }); + ConflictingJvmDeclarationsData data = + new ConflictingJvmDeclarationsData(classInternalName, classOrigin, rawSignature, origins); + diagnostics.report(ErrorsJvm.ACCIDENTAL_OVERRIDE.on(elementToReportOn, data)); + } + } } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/DefaultErrorMessagesJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/DefaultErrorMessagesJvm.java index 519c26215f3..1fdc1bdc161 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/DefaultErrorMessagesJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/DefaultErrorMessagesJvm.java @@ -34,6 +34,7 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension { public static final DiagnosticFactoryToRendererMap MAP = new DiagnosticFactoryToRendererMap(); static { MAP.put(ErrorsJvm.CONFLICTING_JVM_DECLARATIONS, "Platform declaration clash: ''{0}''", CONFLICTING_JVM_DECLARATIONS_DATA); + MAP.put(ErrorsJvm.ACCIDENTAL_OVERRIDE, "Accidental override: ''{0}''", CONFLICTING_JVM_DECLARATIONS_DATA); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/ErrorsJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/ErrorsJvm.java index 54be92a099b..3bd07dc16c4 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/ErrorsJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/ErrorsJvm.java @@ -25,6 +25,7 @@ import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR; public interface ErrorsJvm { DiagnosticFactory1 CONFLICTING_JVM_DECLARATIONS = DiagnosticFactory1.create(ERROR, DECLARATION_OR_DEFAULT); + DiagnosticFactory1 ACCIDENTAL_OVERRIDE = DiagnosticFactory1.create(ERROR, DECLARATION_OR_DEFAULT); @SuppressWarnings("UnusedDeclaration") Object _initializer = new Object() { diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/duplicateJvmSignatureUtil.kt b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/duplicateJvmSignatureUtil.kt index f60baff0324..d83510f5cbd 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/duplicateJvmSignatureUtil.kt +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/duplicateJvmSignatureUtil.kt @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.java.diagnostics.ErrorsJvm.* import org.jetbrains.jet.lang.resolve.java.diagnostics.ConflictingJvmDeclarationsData import org.jetbrains.jet.lang.resolve.java.diagnostics.JvmDeclarationOriginKind.* import org.jetbrains.jet.lang.diagnostics.Errors.* +import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory.* public fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostics): Diagnostics? { fun doGetDiagnostics(): Diagnostics? { @@ -64,7 +65,8 @@ public fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Dia } override fun forElement(psiElement: PsiElement): Collection { - val (conflicting, other) = result.forElement(element).partition { it.getFactory() == CONFLICTING_JVM_DECLARATIONS } + val jvmDiagnostics = setOf(CONFLICTING_JVM_DECLARATIONS, ACCIDENTAL_OVERRIDE) + val (conflicting, other) = result.forElement(element).partition { it.getFactory() in jvmDiagnostics } if (alreadyReported(psiElement)) { // CONFLICTING_OVERLOADS already reported, no need to duplicate it return other @@ -72,7 +74,7 @@ public fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Dia val filtered = arrayListOf() conflicting.groupBy { - CONFLICTING_JVM_DECLARATIONS.cast(it).getA().signature.name + cast(it, jvmDiagnostics).getA().signature.name }.forEach { val diagnostics = it.getValue() if (diagnostics.size <= 1) { @@ -84,8 +86,12 @@ public fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Dia me -> diagnostics.none { other -> - me != other && - CONFLICTING_JVM_DECLARATIONS.cast(other).getA() higherThan CONFLICTING_JVM_DECLARATIONS.cast(me).getA() + me != other && ( + // in case of implementation copied from a super trait there will be both diagnostics on the same signature + me.getFactory() == ACCIDENTAL_OVERRIDE && other.getFactory() == CONFLICTING_JVM_DECLARATIONS + // there are paris of corresponding signatures that frequently clash simultaneously: package facade & part, trait and trait-impl + || cast(other, jvmDiagnostics).getA() higherThan cast(me, jvmDiagnostics).getA() + ) } } ) diff --git a/compiler/testData/cli/jvm/signatureClash.kt b/compiler/testData/cli/jvm/signatureClash.kt index b10d2e5ac30..8950ade0ba9 100644 --- a/compiler/testData/cli/jvm/signatureClash.kt +++ b/compiler/testData/cli/jvm/signatureClash.kt @@ -1,4 +1,10 @@ -class A { +open class B { + val x = 1 +} + +class A : B() { + fun getX() = 1 + fun getA(): Int = 1 val a: Int = 1 } diff --git a/compiler/testData/cli/jvm/signatureClash.out b/compiler/testData/cli/jvm/signatureClash.out index 08d76ffd066..039ac7561a8 100644 --- a/compiler/testData/cli/jvm/signatureClash.out +++ b/compiler/testData/cli/jvm/signatureClash.out @@ -1,5 +1,6 @@ -ERROR: $TESTDATA_DIR$/signatureClash.kt: (2, 5) Platform declaration clash: 'getA()I' -ERROR: $TESTDATA_DIR$/signatureClash.kt: (3, 5) Platform declaration clash: 'getA()I' -ERROR: $TESTDATA_DIR$/signatureClash.kt: (6, 1) Platform declaration clash: 'getB()I' -ERROR: $TESTDATA_DIR$/signatureClash.kt: (7, 1) Platform declaration clash: 'getB()I' +ERROR: $TESTDATA_DIR$/signatureClash.kt: (6, 5) Accidental override: 'getX()I' +ERROR: $TESTDATA_DIR$/signatureClash.kt: (8, 5) Platform declaration clash: 'getA()I' +ERROR: $TESTDATA_DIR$/signatureClash.kt: (9, 5) Platform declaration clash: 'getA()I' +ERROR: $TESTDATA_DIR$/signatureClash.kt: (12, 1) Platform declaration clash: 'getB()I' +ERROR: $TESTDATA_DIR$/signatureClash.kt: (13, 1) Platform declaration clash: 'getB()I' COMPILATION_ERROR \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt index 29bb4c197c8..cb114398459 100644 --- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt @@ -4,5 +4,5 @@ open class B { class C : B() { val x: Int - get() = 1 + get() = 1 } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt new file mode 100644 index 00000000000..817968437b5 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt @@ -0,0 +1,5 @@ +open class B { + fun getX() = 1 +} + +class C(val x: Int) : B() \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt new file mode 100644 index 00000000000..03374ec515a --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt @@ -0,0 +1,7 @@ +open class B { + fun getX() = 1 +} + +class C : B() { + val x: Int = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt index 8c79e89d4ba..8b75df8f99e 100644 --- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt @@ -4,5 +4,5 @@ open class B { } class C : B() { - fun getX() = 1 + fun getX() = 1 } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty.kt new file mode 100644 index 00000000000..b1f56b3144e --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty.kt @@ -0,0 +1,10 @@ +trait B { + fun getX() = 1 +} + +trait D { + val x: Int +} + +class C(d: D) : D by d, B { +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt new file mode 100644 index 00000000000..53be1d192d1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt @@ -0,0 +1,9 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +open class B { + fun foo(l: List) {} +} + +class C : B() { + fun foo(l: List) {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt new file mode 100644 index 00000000000..f6c76cb59ce --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt @@ -0,0 +1,8 @@ +open class B { + private fun getX() = 1 +} + +class C : B() { + val x: Int + get() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt index be5b8557a77..9f4e06890c5 100644 --- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt @@ -4,5 +4,5 @@ trait T { class C : T { val x: Int - get() = 1 + get() = 1 } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyInTrait.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyInTrait.kt new file mode 100644 index 00000000000..7ac61cb4db6 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyInTrait.kt @@ -0,0 +1,8 @@ +trait T { + fun getX() = 1 +} + +trait C : T { + val x: Int + get() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt new file mode 100644 index 00000000000..fd6f97455e4 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt @@ -0,0 +1,8 @@ +trait T { + fun getX(): Int +} + +abstract class C : T { + val x: Int + get() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionInTrait.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionInTrait.kt new file mode 100644 index 00000000000..d969e1791a4 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionInTrait.kt @@ -0,0 +1,8 @@ +trait T { + val x: Int + get() = 1 +} + +trait C : T { + fun getX() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt new file mode 100644 index 00000000000..40b17a13d66 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt @@ -0,0 +1,7 @@ +trait T { + val x: Int +} + +abstract class C : T { + fun getX() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/override/Generics.kt b/compiler/testData/diagnostics/tests/override/Generics.kt index 5dbff912acf..dd17aedf110 100644 --- a/compiler/testData/diagnostics/tests/override/Generics.kt +++ b/compiler/testData/diagnostics/tests/override/Generics.kt @@ -42,7 +42,7 @@ abstract class MyAbstractClass1 : MyTrait, MyAbstractClass() { class MyIllegalGenericClass1 : MyTrait, MyAbstractClass() {} class MyIllegalGenericClass2(r : R) : MyTrait, MyAbstractClass() { - override fun foo(r: R) = r + override fun foo(r: R) = r override val pr : R = r } class MyIllegalClass1 : MyTrait, MyAbstractClass() {} diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index 98cde72dc0d..b67bcd0f543 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -2568,21 +2568,66 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest { doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt"); } + @TestMetadata("classFunctionOverriddenByPropertyInConstructor.kt") + public void testClassFunctionOverriddenByPropertyInConstructor() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt"); + } + + @TestMetadata("classFunctionOverriddenByPropertyNoGetter.kt") + public void testClassFunctionOverriddenByPropertyNoGetter() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt"); + } + @TestMetadata("classPropertyOverriddenByFunction.kt") public void testClassPropertyOverriddenByFunction() throws Exception { doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt"); } + @TestMetadata("delegatedFunctionOverriddenByProperty.kt") + public void testDelegatedFunctionOverriddenByProperty() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty.kt"); + } + + @TestMetadata("genericClassFunction.kt") + public void testGenericClassFunction() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt"); + } + + @TestMetadata("privateClassFunctionOverriddenByProperty.kt") + public void testPrivateClassFunctionOverriddenByProperty() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt"); + } + @TestMetadata("traitFunctionOverriddenByProperty.kt") public void testTraitFunctionOverriddenByProperty() throws Exception { doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt"); } + @TestMetadata("traitFunctionOverriddenByPropertyInTrait.kt") + public void testTraitFunctionOverriddenByPropertyInTrait() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyInTrait.kt"); + } + + @TestMetadata("traitFunctionOverriddenByPropertyNoImpl.kt") + public void testTraitFunctionOverriddenByPropertyNoImpl() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt"); + } + @TestMetadata("traitPropertyOverriddenByFunction.kt") public void testTraitPropertyOverriddenByFunction() throws Exception { doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction.kt"); } + @TestMetadata("traitPropertyOverriddenByFunctionInTrait.kt") + public void testTraitPropertyOverriddenByFunctionInTrait() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionInTrait.kt"); + } + + @TestMetadata("traitPropertyOverriddenByFunctionNoImpl.kt") + public void testTraitPropertyOverriddenByFunctionNoImpl() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt"); + } + } @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure") diff --git a/idea/testData/checker/OverridesAndGenerics.kt b/idea/testData/checker/OverridesAndGenerics.kt index 009961e6adb..92968f88434 100644 --- a/idea/testData/checker/OverridesAndGenerics.kt +++ b/idea/testData/checker/OverridesAndGenerics.kt @@ -25,7 +25,7 @@ class MyIllegalGenericClass1 : MyTrait, MyAbstractClass() {} class MyIllegalGenericClass2 : MyTrait, MyAbstractClass() { - override fun foo(r: R) = r + override fun foo(r: R) = r } class MyIllegalClass1 : MyTrait, MyAbstractClass() {}