diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index c75ec6c2089..ab56d9835b5 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -1196,14 +1196,14 @@ public class JavaDescriptorResolver { Set functionsFromSupertypes = getFunctionsFromSupertypes(scopeData, methodName); - OverrideResolver.generateOverridesInFunctionGroup(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, new OverrideResolver.DescriptorSink() { + OverrideResolver.generateOverridesInFunctionGroup(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, new OverrideResolver.DescriptorSink() { @Override - public void addToScope(@NotNull NamedFunctionDescriptor fakeOverride) { - functions.add(fakeOverride); + public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) { + functions.add((FunctionDescriptor) fakeOverride); } @Override - public void conflict(@NotNull NamedFunctionDescriptor fromSuper, @NotNull NamedFunctionDescriptor fromCurrent) { + public void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent) { // nop } }); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableMemberDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableMemberDescriptor.java index 39c4de90fdc..7aa6fb39ca1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableMemberDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/CallableMemberDescriptor.java @@ -28,6 +28,8 @@ public interface CallableMemberDescriptor extends CallableDescriptor, MemberDesc @Override Set getOverriddenDescriptors(); + void addOverriddenDescriptor(@NotNull CallableMemberDescriptor overridden); + enum Kind { DECLARATION, FAKE_OVERRIDE, diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java index 0417994ceb1..8e98996d7d1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java @@ -97,7 +97,7 @@ public class ConstructorDescriptorImpl extends FunctionDescriptorImpl implements } @Override - public void addOverriddenFunction(@NotNull FunctionDescriptor overriddenFunction) { + public void addOverriddenDescriptor(@NotNull CallableMemberDescriptor overriddenFunction) { throw new UnsupportedOperationException("Constructors cannot override anything"); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java index 7442781597e..e057306bbf3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java @@ -140,8 +140,9 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorImpl i return visibility; } - public void addOverriddenFunction(@NotNull FunctionDescriptor overriddenFunction) { - overriddenFunctions.add(overriddenFunction); + @Override + public void addOverriddenDescriptor(@NotNull CallableMemberDescriptor overriddenFunction) { + overriddenFunctions.add((FunctionDescriptor) overriddenFunction); } @Override @@ -225,7 +226,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorImpl i ); if (copyOverrides) { for (FunctionDescriptor overriddenFunction : overriddenFunctions) { - substitutedDescriptor.addOverriddenFunction(overriddenFunction.substitute(substitutor)); + substitutedDescriptor.addOverriddenDescriptor(overriddenFunction.substitute(substitutor)); } } return substitutedDescriptor; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java index 07415dbae4b..d05a34969c1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java @@ -133,4 +133,9 @@ public abstract class PropertyAccessorDescriptor extends DeclarationDescriptorIm } return overriddenAccessors; } + + @Override + public void addOverriddenDescriptor(@NotNull CallableMemberDescriptor overridden) { + throw new IllegalStateException(); + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java index 61ceb6110c1..0d6d10c3edc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java @@ -275,8 +275,9 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Callab return kind; } - public void addOverriddenDescriptor(PropertyDescriptor overridden) { - overriddenProperties.add(overridden); + @Override + public void addOverriddenDescriptor(@NotNull CallableMemberDescriptor overridden) { + overriddenProperties.add((PropertyDescriptor) overridden); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java index 305ffef2f66..1dff2b795b2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java @@ -150,14 +150,10 @@ public class OverloadResolver { { MultiMap functionsByName = MultiMap.create(); - for (FunctionDescriptor function : classDescriptor.getFunctions()) { + for (CallableMemberDescriptor function : classDescriptor.getCallableMembers()) { functionsByName.putValue(function.getName(), function); } - for (PropertyDescriptor property : classDescriptor.getProperties()) { - functionsByName.putValue(property.getName(), property); - } - for (ConstructorDescriptor nestedClassConstructor : nestedClassConstructors) { functionsByName.putValue(nestedClassConstructor.getContainingDeclaration().getName(), nestedClassConstructor); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java index ef97644c6ae..936f27dda26 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java @@ -85,102 +85,81 @@ public class OverrideResolver { } } - List functionsFromSupertypes = getDescriptorsFromSupertypes(classDescriptor, NamedFunctionDescriptor.class); - List propertiesFromSupertypes = getDescriptorsFromSupertypes(classDescriptor, PropertyDescriptor.class); + List functionsFromSupertypes = getDescriptorsFromSupertypes(classDescriptor); - MultiMap functionsFromSupertypesByName = groupDescriptorsByName(functionsFromSupertypes); - MultiMap propertiesFromSupertypesByName = groupDescriptorsByName(propertiesFromSupertypes); + MultiMap functionsFromSupertypesByName = groupDescriptorsByName(functionsFromSupertypes); + + MultiMap functionsFromCurrentByName = groupDescriptorsByName(classDescriptor.getCallableMembers()); - MultiMap functionsFromCurrentByName = groupDescriptorsByName(classDescriptor.getFunctions()); - MultiMap propertiesFromCurrentByName = groupDescriptorsByName(classDescriptor.getProperties()); - Set functionNames = new HashSet(); functionNames.addAll(functionsFromSupertypesByName.keySet()); functionNames.addAll(functionsFromCurrentByName.keySet()); - Set propertyNames = new HashSet(); - propertyNames.addAll(propertiesFromSupertypesByName.keySet()); - propertyNames.addAll(propertiesFromCurrentByName.keySet()); - - for (String functionName : functionNames) { generateOverridesInFunctionGroup(functionName, functionsFromSupertypesByName.get(functionName), functionsFromCurrentByName.get(functionName), classDescriptor, - new DescriptorSink() { + new DescriptorSink() { @Override - public void addToScope(@NotNull NamedFunctionDescriptor fakeOverride) { - classDescriptor.getScopeForMemberLookupAsWritableScope().addFunctionDescriptor(fakeOverride); + public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) { + if (fakeOverride instanceof PropertyDescriptor) { + classDescriptor.getScopeForMemberLookupAsWritableScope().addPropertyDescriptor((PropertyDescriptor) fakeOverride); + } else if (fakeOverride instanceof NamedFunctionDescriptor) { + classDescriptor.getScopeForMemberLookupAsWritableScope().addFunctionDescriptor((NamedFunctionDescriptor) fakeOverride); + } else { + throw new IllegalStateException(fakeOverride.getClass().getName()); + } } @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())); - } - }); - } - - for (String propertyName : propertyNames) { - generateOverridesInPropertyGroup(propertyName, - propertiesFromSupertypesByName.get(propertyName), - propertiesFromCurrentByName.get(propertyName), - classDescriptor, - new DescriptorSink() { - @Override - 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); + public void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent) { + JetDeclaration jetProperty = (JetDeclaration) context.getTrace().get(BindingContext.DESCRIPTOR_TO_DECLARATION, fromCurrent); context.getTrace().report(Errors.CONFLICTING_OVERLOADS.on(jetProperty, fromCurrent, fromCurrent.getContainingDeclaration().getName())); } }); } } - public interface DescriptorSink { - void addToScope(@NotNull D fakeOverride); + public interface DescriptorSink { + void addToScope(@NotNull CallableMemberDescriptor fakeOverride); - void conflict(@NotNull D fromSuper, @NotNull D fromCurrent); + void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent); } public static void generateOverridesInFunctionGroup( @NotNull String name, - @NotNull Collection functionsFromSupertypes, - @NotNull Collection functionsFromCurrent, + @NotNull Collection functionsFromSupertypes, + @NotNull Collection functionsFromCurrent, @NotNull ClassDescriptor current, - @NotNull DescriptorSink sink) { + @NotNull DescriptorSink sink) { - List fakeOverrides = Lists.newArrayList(); + List fakeOverrides = Lists.newArrayList(); - for (NamedFunctionDescriptor functionFromSupertype : functionsFromSupertypes) { + for (CallableMemberDescriptor functionFromSupertype : functionsFromSupertypes) { boolean overrides = false; - for (NamedFunctionDescriptor functionFromCurrent : functionsFromCurrent) { + for (CallableMemberDescriptor functionFromCurrent : functionsFromCurrent) { OverridingUtil.OverrideCompatibilityInfo.ErrorKind overridable = OverridingUtil.isOverridableBy(functionFromSupertype, functionFromCurrent).isOverridable(); if (overridable == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE) { - ((FunctionDescriptorImpl) functionFromCurrent).addOverriddenFunction(functionFromSupertype); + functionFromCurrent.addOverriddenDescriptor(functionFromSupertype); overrides = true; } else if (overridable == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.CONFLICT) { sink.conflict(functionFromSupertype, functionFromCurrent); } } - for (NamedFunctionDescriptor fakeOverride : fakeOverrides) { + for (CallableMemberDescriptor fakeOverride : fakeOverrides) { if (OverridingUtil.isOverridableBy(functionFromSupertype, fakeOverride).isOverridable() == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE) { - ((FunctionDescriptorImpl) fakeOverride).addOverriddenFunction(functionFromSupertype); + fakeOverride.addOverriddenDescriptor(functionFromSupertype); overrides = true; } } if (!overrides) { - NamedFunctionDescriptor fakeOverride = functionFromSupertype.copy(current, false, CallableMemberDescriptor.Kind.FAKE_OVERRIDE, false); - ((FunctionDescriptorImpl) fakeOverride).addOverriddenFunction(functionFromSupertype); + CallableMemberDescriptor fakeOverride = functionFromSupertype.copy(current, false, CallableMemberDescriptor.Kind.FAKE_OVERRIDE, false); + fakeOverride.addOverriddenDescriptor(functionFromSupertype); fakeOverrides.add(fakeOverride); @@ -188,45 +167,6 @@ public class OverrideResolver { } } } - - public static void generateOverridesInPropertyGroup( - @NotNull String name, - @NotNull Collection propertiesFromSupertypes, - @NotNull Collection propertiesFromCurrent, - @NotNull ClassDescriptor current, - @NotNull DescriptorSink sink) { - - List fakeOverrides = Lists.newArrayList(); - - for (PropertyDescriptor propertyFromSupertype : propertiesFromSupertypes) { - boolean overrides = false; - for (PropertyDescriptor propertyFromCurrent : propertiesFromCurrent) { - 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() == OverridingUtil.OverrideCompatibilityInfo.ErrorKind.OVERRIDABLE) { - ((PropertyDescriptor) fakeOverride).addOverriddenDescriptor(propertyFromSupertype); - overrides = true; - } - } - - if (!overrides) { - PropertyDescriptor fakeOverride = propertyFromSupertype.copy(current, false, CallableMemberDescriptor.Kind.FAKE_OVERRIDE, false); - fakeOverride.addOverriddenDescriptor(propertyFromSupertype); - - fakeOverrides.add(fakeOverride); - - sink.addToScope(fakeOverride); - } - } - } private static MultiMap groupDescriptorsByName(Collection properties) { @@ -238,21 +178,20 @@ public class OverrideResolver { } - private static List getDescriptorsFromSupertypes( - ClassDescriptor classDescriptor, Class descriptorClass) { - Set r = Sets.newHashSet(); + private static List getDescriptorsFromSupertypes(ClassDescriptor classDescriptor) { + Set r = Sets.newHashSet(); for (JetType supertype : classDescriptor.getTypeConstructor().getSupertypes()) { - r.addAll(getDescriptorsOfType(supertype.getMemberScope(), descriptorClass)); + r.addAll(getDescriptorsOfType(supertype.getMemberScope())); } - return new ArrayList(r); + return new ArrayList(r); } - private static List getDescriptorsOfType( - JetScope scope, Class descriptorClass) { - List r = Lists.newArrayList(); + private static List getDescriptorsOfType( + JetScope scope) { + List r = Lists.newArrayList(); for (DeclarationDescriptor decl : scope.getAllDescriptors()) { - if (descriptorClass.isInstance(decl)) { - r.add((T) decl); + if (decl instanceof PropertyDescriptor || decl instanceof NamedFunctionDescriptor) { + r.add((CallableMemberDescriptor) decl); } } return r;