azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

missing error report on incompatible declaration

Browse Source 
===
open class Aaaa() {
    fun bb() = 1
}

class Bbbb() : Aaaa() {
    fun <T> bb() = 1
}
===
This commit is contained in:
Stepan Koltsov
2012-02-19 22:02:33 +04:00
parent 7acc4fe957
commit ca8cf6cb49
10 changed files with 105 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+6 -1
View File
@@ -1198,9 +1198,14 @@ public class JavaDescriptorResolver {
OverrideResolver.generateOverridesInFunctionGroup(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, new OverrideResolver.DescriptorSink<NamedFunctionDescriptor>() {
@Override
public void addToScope(NamedFunctionDescriptor fakeOverride) {
public void addToScope(@NotNull NamedFunctionDescriptor fakeOverride) {
functions.add(fakeOverride);
}
@Override
public void conflict(@NotNull NamedFunctionDescriptor fromSuper, @NotNull NamedFunctionDescriptor fromCurrent) {
// nop
}
});
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/FunctionSignatureDiagnosticFactory.java
+2 -1
View File
@@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.diagnostics;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.psi.JetClass;
import org.jetbrains.jet.lang.psi.JetDeclaration;
@@ -63,7 +64,7 @@ public class FunctionSignatureDiagnosticFactory extends DiagnosticFactoryWithMes
}
@NotNull
public Diagnostic on(@NotNull JetDeclaration declaration, @NotNull FunctionDescriptor functionDescriptor,
public Diagnostic on(@NotNull JetDeclaration declaration, @NotNull CallableMemberDescriptor functionDescriptor,
@NotNull String functionContainer)
{
TextRange rangeToMark = rangeToMark(declaration);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java
+8 -4
View File
@@ -28,10 +28,14 @@ public class OverloadUtil {
*/
public static OverloadCompatibilityInfo isOverloadble(FunctionDescriptor a, FunctionDescriptor b) {
OverridingUtil.OverrideCompatibilityInfo overrideCompatibilityInfo = OverridingUtil.isOverridableByImpl(a, b, false);
if (!overrideCompatibilityInfo.isOverloadable()) {
return OverloadCompatibilityInfo.someError();
} else {
return OverloadCompatibilityInfo.success();
switch (overrideCompatibilityInfo.isOverridable()) {
case OVERRIDABLE:
return OverloadCompatibilityInfo.someError();
case CONFLICT:
case INCOMPATIBLE:
return OverloadCompatibilityInfo.success();
default:
throw new IllegalStateException();
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
+30 -9
View File
@@ -24,6 +24,7 @@ import com.intellij.psi.PsiElement;
import com.intellij.util.containers.MultiMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetType;
@@ -109,9 +110,15 @@ public class OverrideResolver {
classDescriptor,
new DescriptorSink<NamedFunctionDescriptor>() {
@Override
public void addToScope(NamedFunctionDescriptor fakeOverride) {
public void addToScope(@NotNull NamedFunctionDescriptor fakeOverride) {
classDescriptor.getScopeForMemberLookupAsWritableScope().addFunctionDescriptor(fakeOverride);
}
@Override
public void conflict(@NotNull NamedFunctionDescriptor fromSuper, @NotNull NamedFunctionDescriptor fromCurrent) {
JetNamedFunction jetDeclaration = (JetNamedFunction) context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, fromCurrent);
context.getTrace().report(Errors.CONFLICTING_OVERLOADS.on(jetDeclaration, fromCurrent, fromCurrent.getContainingDeclaration().getName()));
}
});
}
@@ -122,15 +129,23 @@ public class OverrideResolver {
classDescriptor,
new DescriptorSink<PropertyDescriptor>() {
@Override
public void addToScope(PropertyDescriptor fakeOverride) {
public void addToScope(@NotNull PropertyDescriptor fakeOverride) {
classDescriptor.getScopeForMemberLookupAsWritableScope().addPropertyDescriptor(fakeOverride);
}
@Override
public void conflict(@NotNull PropertyDescriptor fromSuper, @NotNull PropertyDescriptor fromCurrent) {
JetProperty jetProperty = (JetProperty) context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, fromCurrent);
context.getTrace().report(Errors.CONFLICTING_OVERLOADS.on(jetProperty, fromCurrent, fromCurrent.getContainingDeclaration().getName()));
}
});
}
}
public interface DescriptorSink<D extends CallableMemberDescriptor> {
void addToScope(D fakeOverride);
void addToScope(@NotNull D fakeOverride);
void conflict(@NotNull D fromSuper, @NotNull D fromCurrent);
}
public static void generateOverridesInFunctionGroup(
@@ -147,14 +162,17 @@ public class OverrideResolver {
boolean overrides = false;
for (NamedFunctionDescriptor functionFromCurrent : functionsFromCurrent) {
if (OverridingUtil.isOverridableBy(functionFromSupertype, functionFromCurrent).isOverridable()) {
OverridingUtil.OverrideCompatibilityInfo.ErrorKind overridable = OverridingUtil.isOverridableBy(functionFromSupertype, functionFromCurrent).isOverridable();
if (overridable == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE) {
((FunctionDescriptorImpl) functionFromCurrent).addOverriddenFunction(functionFromSupertype);
overrides = true;
} else if (overridable == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.CONFLICT) {
sink.conflict(functionFromSupertype, functionFromCurrent);
}
}
for (NamedFunctionDescriptor fakeOverride : fakeOverrides) {
if (OverridingUtil.isOverridableBy(functionFromSupertype, fakeOverride).isOverridable()) {
if (OverridingUtil.isOverridableBy(functionFromSupertype, fakeOverride).isOverridable() == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE) {
((FunctionDescriptorImpl) fakeOverride).addOverriddenFunction(functionFromSupertype);
overrides = true;
}
@@ -183,14 +201,17 @@ public class OverrideResolver {
for (PropertyDescriptor propertyFromSupertype : propertiesFromSupertypes) {
boolean overrides = false;
for (PropertyDescriptor propertyFromCurrent : propertiesFromCurrent) {
if (OverridingUtil.isOverridableBy(propertyFromSupertype, propertyFromCurrent).isOverridable()) {
OverridingUtil.OverrideCompatibilityInfo.ErrorKind overridable = OverridingUtil.isOverridableBy(propertyFromSupertype, propertyFromCurrent).isOverridable();
if (overridable == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE) {
propertyFromCurrent.addOverriddenDescriptor(propertyFromSupertype);
overrides = true;
} else if (overridable == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.CONFLICT) {
sink.conflict(propertyFromSupertype, propertyFromCurrent);
}
}
for (PropertyDescriptor fakeOverride : fakeOverrides) {
if (OverridingUtil.isOverridableBy(propertyFromSupertype, fakeOverride).isOverridable()) {
if (OverridingUtil.isOverridableBy(propertyFromSupertype, fakeOverride).isOverridable() == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE) {
((PropertyDescriptor) fakeOverride).addOverriddenDescriptor(propertyFromSupertype);
overrides = true;
}
@@ -374,8 +395,8 @@ public class OverrideResolver {
for (CallableMemberDescriptor another : filteredMembers) {
// if (one == another) continue;
factoredMembers.put(one, one);
if (OverridingUtil.isOverridableBy(one, another).isOverridable()
|| OverridingUtil.isOverridableBy(another, one).isOverridable()) {
if (OverridingUtil.isOverridableBy(one, another).isOverridable() == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE
|| OverridingUtil.isOverridableBy(another, one).isOverridable() == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE) {
factoredMembers.put(one, another);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
+40 -27
View File
@@ -56,8 +56,8 @@ public class OverridingUtil {
for (D otherD : candidates) {
CallableDescriptor other = transform.fun(otherD);
if (me.getOriginal() == other.getOriginal()
&& isOverridableBy(other, me).isOverridable()
&& isOverridableBy(me, other).isOverridable()) {
&& isOverridableBy(other, me).isOverridable() == OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE
&& isOverridableBy(me, other).isOverridable() == OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE) {
continue outerLoop;
}
}
@@ -133,12 +133,6 @@ public class OverridingUtil {
// TODO : Visibility
if (forOverride) {
if (superDescriptor.getTypeParameters().size() != subDescriptor.getTypeParameters().size()) {
return OverrideCompatibilityInfo.typeParameterNumberMismatch();
}
}
if (compiledValueParameterCount(superDescriptor) != compiledValueParameterCount(subDescriptor)) {
return OverrideCompatibilityInfo.valueParameterNumberMismatch();
}
@@ -146,6 +140,20 @@ public class OverridingUtil {
List<JetType> superValueParameters = compiledValueParameters(superDescriptor);
List<JetType> subValueParameters = compiledValueParameters(subDescriptor);
if (forOverride) {
if (superDescriptor.getTypeParameters().size() != subDescriptor.getTypeParameters().size()) {
for (int i = 0; i < superValueParameters.size(); ++i) {
JetType superValueParameterType = getUpperBound(superValueParameters.get(i));
JetType subValueParameterType = getUpperBound(subValueParameters.get(i));
// TODO: compare erasure
if (!JetTypeChecker.INSTANCE.equalTypes(superValueParameterType, subValueParameterType)) {
return OverrideCompatibilityInfo.typeParameterNumberMismatch();
}
}
return OverrideCompatibilityInfo.valueParameterTypeMismatch(null, null, OverrideCompatibilityInfo.ErrorKind.CONFLICT);
}
}
if (forOverride) {
List<TypeParameterDescriptor> superTypeParameters = superDescriptor.getTypeParameters();
@@ -172,18 +180,21 @@ public class OverridingUtil {
JetType subValueParameter = subValueParameters.get(i);
if (!JetTypeChecker.INSTANCE.equalTypes(superValueParameter, subValueParameter, axioms)) {
return OverrideCompatibilityInfo.valueParameterTypeMismatch(superValueParameter, subValueParameter);
return OverrideCompatibilityInfo.valueParameterTypeMismatch(superValueParameter, subValueParameter, OverrideCompatibilityInfo.ErrorKind.INCOMPATIBLE);
}
}
} else {
for (int i = 0; i < superValueParameters.size(); ++i) {
JetType superValueParameterType = getUpperBound(superValueParameters.get(i));
JetType subValueParameterType = getUpperBound(subValueParameters.get(i));
// TODO: compare erasure
if (!JetTypeChecker.INSTANCE.equalTypes(superValueParameterType, subValueParameterType)) {
return OverrideCompatibilityInfo.valueParameterTypeMismatch(superValueParameterType, subValueParameterType);
return OverrideCompatibilityInfo.valueParameterTypeMismatch(superValueParameterType, subValueParameterType, OverrideCompatibilityInfo.ErrorKind.CONFLICT);
}
}
}
// TODO : Default values, varargs etc
@@ -250,7 +261,13 @@ public class OverridingUtil {
public static class OverrideCompatibilityInfo {
private static final OverrideCompatibilityInfo SUCCESS = new OverrideCompatibilityInfo(true, "SUCCESS");
public enum ErrorKind {
OVERRIDABLE,
INCOMPATIBLE,
CONFLICT,
}
private static final OverrideCompatibilityInfo SUCCESS = new OverrideCompatibilityInfo(ErrorKind.OVERRIDABLE, "SUCCESS");
@NotNull
public static OverrideCompatibilityInfo success() {
@@ -259,62 +276,58 @@ public class OverridingUtil {
@NotNull
public static OverrideCompatibilityInfo nameMismatch() {
return new OverrideCompatibilityInfo(false, "nameMismatch"); // TODO
return new OverrideCompatibilityInfo(ErrorKind.INCOMPATIBLE, "nameMismatch"); // TODO
}
@NotNull
public static OverrideCompatibilityInfo typeParameterNumberMismatch() {
return new OverrideCompatibilityInfo(false, "typeParameterNumberMismatch"); // TODO
return new OverrideCompatibilityInfo(ErrorKind.INCOMPATIBLE, "typeParameterNumberMismatch"); // TODO
}
@NotNull
public static OverrideCompatibilityInfo valueParameterNumberMismatch() {
return new OverrideCompatibilityInfo(false, "valueParameterNumberMismatch"); // TODO
return new OverrideCompatibilityInfo(ErrorKind.INCOMPATIBLE, "valueParameterNumberMismatch"); // TODO
}
@NotNull
public static OverrideCompatibilityInfo boundsMismatch(TypeParameterDescriptor superTypeParameter, TypeParameterDescriptor subTypeParameter) {
return new OverrideCompatibilityInfo(false, "boundsMismatch"); // TODO
return new OverrideCompatibilityInfo(ErrorKind.INCOMPATIBLE, "boundsMismatch"); // TODO
}
@NotNull
public static OverrideCompatibilityInfo valueParameterTypeMismatch(JetType superValueParameter, JetType subValueParameter) {
return new OverrideCompatibilityInfo(false, "valueParameterTypeMismatch"); // TODO
public static OverrideCompatibilityInfo valueParameterTypeMismatch(JetType superValueParameter, JetType subValueParameter, ErrorKind errorKind) {
return new OverrideCompatibilityInfo(errorKind, "valueParameterTypeMismatch"); // TODO
}
@NotNull
public static OverrideCompatibilityInfo memberKindMismatch() {
return new OverrideCompatibilityInfo(false, "memberKindMismatch"); // TODO
return new OverrideCompatibilityInfo(ErrorKind.INCOMPATIBLE, "memberKindMismatch"); // TODO
}
@NotNull
public static OverrideCompatibilityInfo returnTypeMismatch(JetType substitutedSuperReturnType, JetType unsubstitutedSubReturnType) {
return new OverrideCompatibilityInfo(true, "returnTypeMismatch: " + unsubstitutedSubReturnType + " >< " + substitutedSuperReturnType); // TODO
return new OverrideCompatibilityInfo(ErrorKind.CONFLICT, "returnTypeMismatch: " + unsubstitutedSubReturnType + " >< " + substitutedSuperReturnType); // TODO
}
@NotNull
public static OverrideCompatibilityInfo varOverriddenByVal() {
return new OverrideCompatibilityInfo(false, "varOverriddenByVal"); // TODO
return new OverrideCompatibilityInfo(ErrorKind.INCOMPATIBLE, "varOverriddenByVal"); // TODO
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private final boolean overridable;
private final ErrorKind overridable;
private final String message;
public OverrideCompatibilityInfo(boolean success, String message) {
public OverrideCompatibilityInfo(ErrorKind success, String message) {
this.overridable = success;
this.message = message;
}
public boolean isOverridable() {
public ErrorKind isOverridable() {
return overridable;
}
public boolean isOverloadable() {
return !overridable;
}
public String getMessage() {
return message;
}
compiler/testData/diagnostics/tests/override/ComplexValRedeclaration.jet
+1 -1
View File
@@ -5,5 +5,5 @@ abstract class MyAbstractClass<T> {
}
abstract class MyLegalAbstractClass2<T>(t : T) : MyAbstractClass<Int>() {
val <R> <!REDECLARATION!>pr<!> : T = t
<!CONFLICTING_OVERLOADS!>val <R> <!REDECLARATION!>pr<!> : T = t<!>
}
compiler/testData/diagnostics/tests/override/ConflictingFunctionSignatureFromSuperclass.jet
+7
View File
@@ -0,0 +1,7 @@
open class Aaa() {
fun foo() = 1
}
open class Bbb() : Aaa() {
<!CONFLICTING_OVERLOADS!>fun <T> foo()<!> = 2
}
compiler/testData/diagnostics/tests/override/ConflictingPropertySignatureFromSuperclass.jet
+7
View File
@@ -0,0 +1,7 @@
open class Aaa() {
val <!REDECLARATION!>bar<!> = 1
}
open class Bbb() : Aaa() {
<!CONFLICTING_OVERLOADS!>val <T> <!REDECLARATION!>bar<!> = "aa"<!>
}
compiler/testData/diagnostics/tests/override/Generics.jet
+3 -3
View File
@@ -43,7 +43,7 @@ abstract class MyAbstractClass1 : MyTrait<Int>, MyAbstractClass<String>() {
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T>() {}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass2<!><T, R>(r : R) : MyTrait<T>, MyAbstractClass<R>() {
<!NOTHING_TO_OVERRIDE!>override<!> fun foo(r: R) = r
<!NOTHING_TO_OVERRIDE!>override<!> val <T> <!REDECLARATION!>pr<!> : R = r
<!CONFLICTING_OVERLOADS!><!NOTHING_TO_OVERRIDE!>override<!> val <T> <!REDECLARATION!>pr<!> : R = r<!>
}
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass1<!> : MyTrait<Int>, MyAbstractClass<String>() {}
abstract class MyLegalAbstractClass1 : MyTrait<Int>, MyAbstractClass<String>() {}
@@ -51,10 +51,10 @@ abstract class MyLegalAbstractClass1 : MyTrait<Int>, MyAbstractClass<String>() {
class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!><T>(t : T) : MyTrait<Int>, MyAbstractClass<Int>() {
fun foo(t: T) = t
fun bar(t: T) = t
val <R> <!REDECLARATION!>pr<!> : T = t
<!CONFLICTING_OVERLOADS!>val <R> <!REDECLARATION!>pr<!> : T = t<!>
}
abstract class MyLegalAbstractClass2<T>(t : T) : MyTrait<Int>, MyAbstractClass<Int>() {
fun foo(t: T) = t
fun bar(t: T) = t
val <R> <!REDECLARATION!>pr<!> : T = t
<!CONFLICTING_OVERLOADS!>val <R> <!REDECLARATION!>pr<!> : T = t<!>
}
compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java
+1 -1
View File
@@ -156,7 +156,7 @@ public class JetOverridingTest extends JetLiteFixture {
FunctionDescriptor a = makeFunction(superFun);
FunctionDescriptor b = makeFunction(subFun);
OverridingUtil.OverrideCompatibilityInfo overridableWith = OverridingUtil.isOverridableBy(a, b);
assertEquals(overridableWith.getMessage(), expectedIsError, !overridableWith.isOverridable());
assertEquals(overridableWith.getMessage(), expectedIsError, overridableWith.isOverridable() != OverridingUtil.OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE);
}
private FunctionDescriptor makeFunction(String funDecl) {