diff --git a/compiler/backend-common/src/bridges/impl.kt b/compiler/backend-common/src/bridges/impl.kt index adb0ccd45b8..cece5f0c909 100644 --- a/compiler/backend-common/src/bridges/impl.kt +++ b/compiler/backend-common/src/bridges/impl.kt @@ -18,7 +18,7 @@ package org.jetbrains.jet.codegen.bridges import org.jetbrains.jet.lang.descriptors.* import org.jetbrains.jet.lang.resolve.DescriptorUtils -import org.jetbrains.jet.lang.resolve.OverridingUtil +import org.jetbrains.jet.lang.resolve.OverrideResolver import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil import org.jetbrains.jet.lang.types.TypeUtils @@ -72,8 +72,8 @@ public fun findTraitImplementation(descriptor: CallableMemberDescriptor): Callab // TODO: this logic is quite common for bridge generation, find a way to abstract it to a single place // TODO: don't use filterOutOverridden() here, it's an internal front-end utility (see its implementation) - val overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(descriptor) - val filteredOverriddenDeclarations = OverridingUtil.filterOutOverridden(overriddenDeclarations) + val overriddenDeclarations = OverrideResolver.getOverriddenDeclarations(descriptor) + val filteredOverriddenDeclarations = OverrideResolver.filterOutOverridden(overriddenDeclarations) var implementation: CallableMemberDescriptor? = null for (overriddenDeclaration in filteredOverriddenDeclarations) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 4e3a2e47415..b160891f003 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -40,7 +40,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; @@ -682,7 +682,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { return true; } - for (CallableDescriptor overridden : OverridingUtil.getOverriddenDeclarations(function)) { + for (CallableDescriptor overridden : OverrideResolver.getOverriddenDeclarations(function)) { if (overridden instanceof CallableMemberDescriptor && ((CallableMemberDescriptor) overridden).getKind() == CallableMemberDescriptor.Kind.DECLARATION && !overridden.getContainingDeclaration().equals(KotlinBuiltIns.getInstance().getAny())) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java index 0cd878ebd10..5068ac15088 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java @@ -26,6 +26,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.OverridingUtil; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesUtil; import org.jetbrains.jet.lang.resolve.java.structure.*; @@ -34,14 +35,12 @@ import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.SubstitutionUtils; import org.jetbrains.jet.lang.types.TypeSubstitution; import org.jetbrains.jet.lang.types.TypeSubstitutor; -import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import javax.inject.Inject; import java.util.ArrayList; import java.util.List; import static org.jetbrains.jet.lang.resolve.OverridingUtil.isOverridableBy; -import static org.jetbrains.jet.lang.resolve.OverridingUtil.isReturnTypeOkForOverride; public class PsiBasedMethodSignatureChecker implements MethodSignatureChecker { private static final Logger LOG = Logger.getInstance(PsiBasedMethodSignatureChecker.class); @@ -80,7 +79,7 @@ public class PsiBasedMethodSignatureChecker implements MethodSignatureChecker { OverridingUtil.OverrideCompatibilityInfo.Result overridableResult = isOverridableBy(superFunctionSubstituted, function).getResult(); boolean paramsOk = overridableResult == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE; - boolean returnTypeOk = isReturnTypeOkForOverride(JetTypeChecker.INSTANCE, superFunctionSubstituted, function); + boolean returnTypeOk = OverrideResolver.isReturnTypeOkForOverride(superFunctionSubstituted, function); if (!paramsOk || !returnTypeOk) { // This should be a LOG.error, but happens a lot of times incorrectly (e.g. on Kotlin project), because somewhere in the // type checker we compare two types which seem the same but have different instances of class descriptors. It happens 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 5ce56b962c1..022690cd901 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java @@ -21,11 +21,13 @@ import com.google.common.collect.Maps; import com.google.common.collect.Sets; import com.intellij.lang.ASTNode; import com.intellij.psi.PsiElement; +import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; import com.intellij.util.containers.LinkedMultiMap; import com.intellij.util.containers.MultiMap; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.ReadOnly; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor; @@ -33,7 +35,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; @@ -41,6 +43,7 @@ import org.jetbrains.jet.lexer.JetTokens; import javax.inject.Inject; import java.util.*; +import static org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.*; import static org.jetbrains.jet.lang.diagnostics.Errors.*; import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE; @@ -179,6 +182,94 @@ public class OverrideResolver { }); } + private static enum Filtering { + RETAIN_OVERRIDING, + RETAIN_OVERRIDDEN + } + + @NotNull + public static Set filterOutOverridden(@NotNull Set candidateSet) { + //noinspection unchecked + return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDING); + } + + @NotNull + public static Set filterOutOverriding(@NotNull Set candidateSet) { + //noinspection unchecked + return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDDEN); + } + + @NotNull + public static Set filterOutOverridden( + @NotNull Set candidateSet, + @NotNull Function transform + ) { + return filterOverrides(candidateSet, transform, Filtering.RETAIN_OVERRIDING); + } + + @NotNull + private static Set filterOverrides( + @NotNull Set candidateSet, + @NotNull Function transform, + @NotNull Filtering filtering + ) { + Set candidates = Sets.newLinkedHashSet(); + outerLoop: + for (D meD : candidateSet) { + CallableDescriptor me = transform.fun(meD); + for (D otherD : candidateSet) { + CallableDescriptor other = transform.fun(otherD); + if (me == other) continue; + if (filtering == Filtering.RETAIN_OVERRIDING) { + if (overrides(other, me)) { + continue outerLoop; + } + } + else if (filtering == Filtering.RETAIN_OVERRIDDEN) { + if (overrides(me, other)) { + continue outerLoop; + } + } + else { + throw new AssertionError("Unexpected Filtering object: " + filtering); + } + } + for (D otherD : candidates) { + CallableDescriptor other = transform.fun(otherD); + if (me.getOriginal() == other.getOriginal() + && OverridingUtil.isOverridableBy(other, me).getResult() == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE + && OverridingUtil.isOverridableBy(me, other).getResult() == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE) { + continue outerLoop; + } + } + candidates.add(meD); + } + return candidates; + } + + public static boolean overrides(@NotNull D f, @NotNull D g) { + CallableDescriptor originalG = g.getOriginal(); + for (CallableDescriptor overriddenFunction : getAllOverriddenDescriptors(f)) { + if (originalG.equals(overriddenFunction.getOriginal())) return true; + } + return false; + } + + @NotNull + public static Set getAllOverriddenDescriptors(@NotNull CallableDescriptor f) { + Set result = new LinkedHashSet(); + collectAllOverriddenDescriptors(f.getOriginal(), result); + return result; + } + + private static void collectAllOverriddenDescriptors(@NotNull CallableDescriptor current, @NotNull Set result) { + if (result.contains(current)) return; + for (CallableDescriptor descriptor : current.getOriginal().getOverriddenDescriptors()) { + collectAllOverriddenDescriptors(descriptor, result); + result.add(descriptor); + } + } + private static MultiMap groupDescriptorsByName(Collection properties) { MultiMap r = new LinkedMultiMap(); for (T property : properties) { @@ -278,7 +369,7 @@ public class OverrideResolver { Map> overriddenDeclarationsByDirectParent = collectOverriddenDeclarations(directOverridden); List allOverriddenDeclarations = ContainerUtil.flatten(overriddenDeclarationsByDirectParent.values()); - Set allFilteredOverriddenDeclarations = OverridingUtil.filterOutOverridden( + Set allFilteredOverriddenDeclarations = filterOutOverridden( Sets.newLinkedHashSet(allOverriddenDeclarations)); Set relevantDirectlyOverridden = @@ -384,13 +475,43 @@ public class OverrideResolver { ) { Map> overriddenDeclarationsByDirectParent = Maps.newLinkedHashMap(); for (CallableMemberDescriptor descriptor : directOverriddenDescriptors) { - Set overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(descriptor); - Set filteredOverrides = OverridingUtil.filterOutOverridden(overriddenDeclarations); + Set overriddenDeclarations = getOverriddenDeclarations(descriptor); + Set filteredOverrides = filterOutOverridden(overriddenDeclarations); overriddenDeclarationsByDirectParent.put(descriptor, new LinkedHashSet(filteredOverrides)); } return overriddenDeclarationsByDirectParent; } + /** + * @return overridden real descriptors (not fake overrides). Note that all usages of this method should be followed by calling + * {@link #filterOutOverridden(java.util.Set)} or {@link #filterOutOverriding(java.util.Set)}, because some of the declarations + * can override the other + * TODO: merge this method with filterOutOverridden + */ + @NotNull + public static Set getOverriddenDeclarations(@NotNull CallableMemberDescriptor descriptor) { + Set result = new LinkedHashSet(); + getOverriddenDeclarations(descriptor, result); + return result; + } + + private static void getOverriddenDeclarations( + @NotNull CallableMemberDescriptor descriptor, + @NotNull Set result + ) { + if (descriptor.getKind().isReal()) { + result.add(descriptor); + } + else { + if (descriptor.getOverriddenDescriptors().isEmpty()) { + throw new IllegalStateException("No overridden descriptors found for (fake override) " + descriptor); + } + for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) { + getOverriddenDeclarations(overridden, result); + } + } + } + private interface CheckOverrideReportStrategy { void overridingFinalMember(@NotNull CallableMemberDescriptor overridden); @@ -490,22 +611,22 @@ public class OverrideResolver { Set overriddenDescriptors = declared.getOverriddenDescriptors(); for (CallableMemberDescriptor overridden : overriddenDescriptors) { - if (overridden != null) { - if (!overridden.getModality().isOverridable()) { - reportError.overridingFinalMember(overridden); - } + if (overridden == null) continue; - if (declared instanceof PropertyDescriptor && !OverridingUtil.isPropertyTypeOkForOverride( - JetTypeChecker.INSTANCE, (PropertyDescriptor) overridden, (PropertyDescriptor) declared)) { - reportError.propertyTypeMismatchOnOverride(overridden); - } - else if (!OverridingUtil.isReturnTypeOkForOverride(JetTypeChecker.INSTANCE, overridden, declared)) { - reportError.returnTypeMismatchOnOverride(overridden); - } + if (!overridden.getModality().isOverridable()) { + reportError.overridingFinalMember(overridden); + } - if (checkPropertyKind(overridden, true) && checkPropertyKind(declared, false)) { - reportError.varOverriddenByVal(overridden); - } + if (declared instanceof PropertyDescriptor && + !isPropertyTypeOkForOverride((PropertyDescriptor) overridden, (PropertyDescriptor) declared)) { + reportError.propertyTypeMismatchOnOverride(overridden); + } + else if (!isReturnTypeOkForOverride(overridden, declared)) { + reportError.returnTypeMismatchOnOverride(overridden); + } + + if (checkPropertyKind(overridden, true) && checkPropertyKind(declared, false)) { + reportError.varOverriddenByVal(overridden); } } @@ -524,6 +645,60 @@ public class OverrideResolver { } } + public static boolean isReturnTypeOkForOverride( + @NotNull CallableDescriptor superDescriptor, + @NotNull CallableDescriptor subDescriptor + ) { + TypeSubstitutor typeSubstitutor = prepareTypeSubstitutor(superDescriptor, subDescriptor); + if (typeSubstitutor == null) return false; + + JetType superReturnType = superDescriptor.getReturnType(); + assert superReturnType != null; + + JetType subReturnType = subDescriptor.getReturnType(); + assert subReturnType != null; + + JetType substitutedSuperReturnType = typeSubstitutor.substitute(superReturnType, Variance.OUT_VARIANCE); + assert substitutedSuperReturnType != null; + + return JetTypeChecker.INSTANCE.isSubtypeOf(subReturnType, substitutedSuperReturnType); + } + + @Nullable + private static TypeSubstitutor prepareTypeSubstitutor( + @NotNull CallableDescriptor superDescriptor, + @NotNull CallableDescriptor subDescriptor + ) { + List superTypeParameters = superDescriptor.getTypeParameters(); + List subTypeParameters = subDescriptor.getTypeParameters(); + if (subTypeParameters.size() != superTypeParameters.size()) return null; + + Map substitutionContext = Maps.newHashMapWithExpectedSize(superTypeParameters.size()); + for (int i = 0; i < superTypeParameters.size(); i++) { + TypeParameterDescriptor superTypeParameter = superTypeParameters.get(i); + TypeParameterDescriptor subTypeParameter = subTypeParameters.get(i); + substitutionContext.put( + superTypeParameter.getTypeConstructor(), + new TypeProjectionImpl(subTypeParameter.getDefaultType()) + ); + } + return TypeSubstitutor.create(substitutionContext); + } + + public static boolean isPropertyTypeOkForOverride( + @NotNull PropertyDescriptor superDescriptor, + @NotNull PropertyDescriptor subDescriptor + ) { + TypeSubstitutor typeSubstitutor = prepareTypeSubstitutor(superDescriptor, subDescriptor); + if (typeSubstitutor == null) return false; + + if (!superDescriptor.isVar()) return true; + + JetType substitutedSuperReturnType = typeSubstitutor.substitute(superDescriptor.getType(), Variance.OUT_VARIANCE); + assert substitutedSuperReturnType != null; + return JetTypeChecker.INSTANCE.equalTypes(subDescriptor.getType(), substitutedSuperReturnType); + } + private void checkOverrideForComponentFunction(@NotNull final CallableMemberDescriptor componentFunction) { final JetAnnotationEntry dataAnnotation = findDataAnnotationForDataClass(componentFunction.getContainingDeclaration()); @@ -731,4 +906,59 @@ public class OverrideResolver { } } } + + @NotNull + public static Set getDirectlyOverriddenDeclarations(@NotNull D descriptor) { + Set result = Sets.newHashSet(); + //noinspection unchecked + Set overriddenDescriptors = (Set) descriptor.getOverriddenDescriptors(); + for (D overriddenDescriptor : overriddenDescriptors) { + CallableMemberDescriptor.Kind kind = overriddenDescriptor.getKind(); + if (kind == DECLARATION) { + result.add(overriddenDescriptor); + } + else if (kind == FAKE_OVERRIDE || kind == DELEGATION) { + result.addAll(getDirectlyOverriddenDeclarations(overriddenDescriptor)); + } + else if (kind == SYNTHESIZED) { + //do nothing + } + else { + throw new AssertionError("Unexpected callable kind " + kind); + } + } + return filterOutOverridden(result); + } + + @NotNull + public static Set getAllOverriddenDeclarations(@NotNull D memberDescriptor) { + Set result = Sets.newHashSet(); + for (CallableMemberDescriptor overriddenDeclaration : memberDescriptor.getOverriddenDescriptors()) { + CallableMemberDescriptor.Kind kind = overriddenDeclaration.getKind(); + if (kind == DECLARATION) { + //noinspection unchecked + result.add((D) overriddenDeclaration); + } + else if (kind == DELEGATION || kind == FAKE_OVERRIDE || kind == SYNTHESIZED) { + //do nothing + } + else { + throw new AssertionError("Unexpected callable kind " + kind); + } + //noinspection unchecked + result.addAll(getAllOverriddenDeclarations((D) overriddenDeclaration)); + } + return result; + } + + @NotNull + @ReadOnly + public static Set getDeepestSuperDeclarations(@NotNull D functionDescriptor) { + Set overriddenDeclarations = getAllOverriddenDeclarations(functionDescriptor); + if (overriddenDeclarations.isEmpty()) { + return Collections.singleton(functionDescriptor); + } + + return filterOutOverriding(overriddenDeclarations); + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java index 91d179bd635..e153314e2a8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java @@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace; import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall; import org.jetbrains.jet.lang.types.JetType; @@ -135,8 +135,8 @@ public class OverloadingConflictResolver { } - if (OverridingUtil.overrides(f, g)) return true; - if (OverridingUtil.overrides(g, f)) return false; + if (OverrideResolver.overrides(f, g)) return true; + if (OverrideResolver.overrides(g, f)) return false; ReceiverParameterDescriptor receiverOfF = f.getReceiverParameter(); ReceiverParameterDescriptor receiverOfG = g.getReceiverParameter(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionResultsHandler.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionResultsHandler.java index 954f52766ed..c6daa385ce9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionResultsHandler.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionResultsHandler.java @@ -20,7 +20,7 @@ import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace; import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy; @@ -142,7 +142,7 @@ public class ResolutionResultsHandler { assert false : "Should not be reachable, cause every status must belong to some level"; - Set> noOverrides = OverridingUtil.filterOutOverridden(failedCandidates, MAP_TO_CANDIDATE); + Set> noOverrides = OverrideResolver.filterOutOverridden(failedCandidates, MAP_TO_CANDIDATE); if (noOverrides.size() != 1) { tracing.noneApplicable(trace, noOverrides); tracing.recordAmbiguity(trace, noOverrides); @@ -203,7 +203,7 @@ public class ResolutionResultsHandler { } } - Set> noOverrides = OverridingUtil.filterOutOverridden(candidates, MAP_TO_RESULT); + Set> noOverrides = OverrideResolver.filterOutOverridden(candidates, MAP_TO_RESULT); if (noOverrides.size() == 1) { return OverloadResolutionResultsImpl.success(noOverrides.iterator().next()); } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java index 25d9a634929..9a5991fae88 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java @@ -18,22 +18,20 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.base.Predicate; import com.google.common.collect.*; -import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.annotations.ReadOnly; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.PropertyAccessorDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.*; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeConstructor; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import java.util.*; -import static org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.*; import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.CONFLICT; import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE; @@ -48,96 +46,6 @@ public class OverridingUtil { private OverridingUtil() { } - private static enum Filtering { - RETAIN_OVERRIDING, - RETAIN_OVERRIDDEN - } - - @NotNull - public static Set filterOutOverridden(@NotNull Set candidateSet) { - //noinspection unchecked - return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDING); - } - - @NotNull - public static Set filterOutOverriding(@NotNull Set candidateSet) { - //noinspection unchecked - return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDDEN); - } - - @NotNull - public static Set filterOutOverridden( - @NotNull Set candidateSet, - @NotNull Function transform - ) { - return filterOverrides(candidateSet, transform, Filtering.RETAIN_OVERRIDING); - } - - @NotNull - private static Set filterOverrides( - @NotNull Set candidateSet, - @NotNull Function transform, - @NotNull Filtering filtering - ) { - Set candidates = Sets.newLinkedHashSet(); - outerLoop: - for (D meD : candidateSet) { - CallableDescriptor me = transform.fun(meD); - for (D otherD : candidateSet) { - CallableDescriptor other = transform.fun(otherD); - if (me == other) continue; - if (filtering == Filtering.RETAIN_OVERRIDING) { - if (overrides(other, me)) { - continue outerLoop; - } - } - else if (filtering == Filtering.RETAIN_OVERRIDDEN) { - if (overrides(me, other)) { - continue outerLoop; - } - } - else { - throw new AssertionError("Unexpected Filtering object: " + filtering); - } - } - for (D otherD : candidates) { - CallableDescriptor other = transform.fun(otherD); - if (me.getOriginal() == other.getOriginal() - && isOverridableBy(other, me).getResult() == OverrideCompatibilityInfo.Result.OVERRIDABLE - && isOverridableBy(me, other).getResult() == OverrideCompatibilityInfo.Result.OVERRIDABLE) { - continue outerLoop; - } - } - candidates.add(meD); - } - return candidates; - } - - public static boolean overrides(@NotNull D f, @NotNull D g) { - CallableDescriptor originalG = g.getOriginal(); - for (CallableDescriptor overriddenFunction : getAllOverriddenDescriptors(f)) { - if (originalG.equals(overriddenFunction.getOriginal())) return true; - } - return false; - } - - public static Set getAllOverriddenDescriptors(CallableDescriptor f) { - Set overriddenDescriptors = Sets.newHashSet(); - collectAllOverriddenDescriptors(f.getOriginal(), overriddenDescriptors); - return overriddenDescriptors; - } - - private static void collectAllOverriddenDescriptors( - @NotNull CallableDescriptor current, - @NotNull Set result - ) { - if (result.contains(current)) return; - for (CallableDescriptor descriptor : current.getOriginal().getOverriddenDescriptors()) { - collectAllOverriddenDescriptors(descriptor, result); - result.add(descriptor); - } - } - @NotNull public static OverrideCompatibilityInfo isOverridableBy(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) { if (superDescriptor instanceof FunctionDescriptor) { @@ -271,77 +179,6 @@ public class OverridingUtil { } } - public static boolean isReturnTypeOkForOverride(@NotNull JetTypeChecker typeChecker, @NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) { - TypeSubstitutor typeSubstitutor = prepareTypeSubstitutor(superDescriptor, subDescriptor); - if (typeSubstitutor == null) return false; - - JetType superReturnType = superDescriptor.getReturnType(); - assert superReturnType != null; - - JetType subReturnType = subDescriptor.getReturnType(); - assert subReturnType != null; - - JetType substitutedSuperReturnType = typeSubstitutor.substitute(superReturnType, Variance.OUT_VARIANCE); - assert substitutedSuperReturnType != null; - - return typeChecker.isSubtypeOf(subReturnType, substitutedSuperReturnType); - } - - @Nullable - private static TypeSubstitutor prepareTypeSubstitutor(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) { - List superTypeParameters = superDescriptor.getTypeParameters(); - List subTypeParameters = subDescriptor.getTypeParameters(); - if (subTypeParameters.size() != superTypeParameters.size()) return null; - - Map substitutionContext = Maps.newHashMap(); - for (int i = 0; i < superTypeParameters.size(); i++) { - substitutionContext.put( - superTypeParameters.get(i).getTypeConstructor(), - new TypeProjectionImpl(subTypeParameters.get(i).getDefaultType()) - ); - } - return TypeSubstitutor.create(substitutionContext); - } - - public static boolean isPropertyTypeOkForOverride( - @NotNull JetTypeChecker typeChecker, - @NotNull PropertyDescriptor superDescriptor, - @NotNull PropertyDescriptor subDescriptor - ) { - TypeSubstitutor typeSubstitutor = prepareTypeSubstitutor(superDescriptor, subDescriptor); - if (typeSubstitutor == null) return false; - JetType substitutedSuperReturnType = typeSubstitutor.substitute(superDescriptor.getType(), Variance.OUT_VARIANCE); - assert substitutedSuperReturnType != null; - return !superDescriptor.isVar() || typeChecker.equalTypes(subDescriptor.getType(), substitutedSuperReturnType); - } - - /** - * Get overridden descriptors that are declarations, delegations or synthesized and are not dominated by any other such descriptor - */ - @NotNull - public static Set getOverriddenDeclarations(@NotNull CallableMemberDescriptor descriptor) { - Set result = new LinkedHashSet(); - getOverriddenDeclarations(descriptor, result); - return result; - } - - private static void getOverriddenDeclarations( - @NotNull CallableMemberDescriptor descriptor, - @NotNull Set result - ) { - if (descriptor.getKind().isReal()) { - result.add(descriptor); - } - else { - if (descriptor.getOverriddenDescriptors().isEmpty()) { - throw new IllegalStateException("No overridden descriptors found for (fake override) " + descriptor); - } - for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) { - getOverriddenDeclarations(overridden, result); - } - } - } - public static void bindOverride(CallableMemberDescriptor fromCurrent, CallableMemberDescriptor fromSupertype) { fromCurrent.addOverriddenDescriptor(fromSupertype); @@ -593,6 +430,8 @@ public class OverridingUtil { maxVisibility = visibility; } } + // TODO: IDEA seems to issue an incorrect warning here + //noinspection ConstantConditions if (maxVisibility == null) { return null; } @@ -698,70 +537,4 @@ public class OverridingUtil { return message; } } - - @NotNull - public static Set getDirectlyOverriddenDeclarations(@NotNull CallableMemberDescriptor descriptor) { - Set result = Sets.newHashSet(); - Set overriddenDescriptors = descriptor.getOverriddenDescriptors(); - for (CallableMemberDescriptor overriddenDescriptor : overriddenDescriptors) { - CallableMemberDescriptor.Kind kind = overriddenDescriptor.getKind(); - if (kind == DECLARATION) { - result.add(overriddenDescriptor); - } - else if (kind == FAKE_OVERRIDE || kind == DELEGATION) { - result.addAll(getDirectlyOverriddenDeclarations(overriddenDescriptor)); - } - else if (kind == SYNTHESIZED) { - //do nothing - } - else { - throw new AssertionError("Unexpected callable kind " + kind); - } - } - return filterOutOverridden(result); - } - - @NotNull - public static Set getDirectlyOverriddenDeclarations(@NotNull FunctionDescriptor descriptor) { - //noinspection unchecked - return (Set) getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor); - } - - @NotNull - public static Set getDirectlyOverriddenDeclarations(@NotNull PropertyDescriptor descriptor) { - //noinspection unchecked - return (Set) getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor); - } - - @NotNull - public static Set getAllOverriddenDeclarations(@NotNull T memberDescriptor) { - Set result = Sets.newHashSet(); - for (CallableMemberDescriptor overriddenDeclaration : memberDescriptor.getOverriddenDescriptors()) { - CallableMemberDescriptor.Kind kind = overriddenDeclaration.getKind(); - if (kind == DECLARATION) { - //noinspection unchecked - result.add((T) overriddenDeclaration); - } - else if (kind == DELEGATION || kind == FAKE_OVERRIDE || kind == SYNTHESIZED) { - //do nothing - } - else { - throw new AssertionError("Unexpected callable kind " + kind); - } - //noinspection unchecked - result.addAll(getAllOverriddenDeclarations((T) overriddenDeclaration)); - } - return result; - } - - @NotNull - @ReadOnly - public static Set getDeepestSuperDeclarations(T functionDescriptor) { - Set overriddenDeclarations = getAllOverriddenDeclarations(functionDescriptor); - if (overriddenDeclarations.isEmpty()) { - return Collections.singleton(functionDescriptor); - } - - return filterOutOverriding(overriddenDeclarations); - } } diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/GotoSuperActionHandler.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/GotoSuperActionHandler.java index c18d7f3b80c..a7579c7356d 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/GotoSuperActionHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/GotoSuperActionHandler.java @@ -36,7 +36,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; -import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.JetBundle; @@ -83,7 +83,7 @@ public class GotoSuperActionHandler implements CodeInsightActionHandler { message = JetBundle.message("goto.super.class.chooser.title"); } else if (descriptor instanceof CallableMemberDescriptor) { - superDescriptors = OverridingUtil.getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor); + superDescriptors = OverrideResolver.getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor); if (descriptor instanceof PropertyDescriptor) { message = JetBundle.message("goto.super.property.chooser.title"); } diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideMethodsHandler.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideMethodsHandler.java index 7ccf96eba31..badacc99b2b 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideMethodsHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideMethodsHandler.java @@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.OverridingUtil; import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil; import org.jetbrains.jet.lang.types.JetType; @@ -67,7 +68,7 @@ public class OverrideMethodsHandler extends OverrideImplementMethodsHandler { } // Only those actually inherited - Set filteredMembers = OverridingUtil.filterOutOverridden(inheritedFunctions); + Set filteredMembers = OverrideResolver.filterOutOverridden(inheritedFunctions); // Group members with "the same" signature Multimap factoredMembers = LinkedHashMultimap.create(); diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java index 8e4ce03a10c..cc4604378cf 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java @@ -58,7 +58,7 @@ import org.jetbrains.jet.lang.descriptors.Modality; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; -import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.JetPluginUtil; @@ -246,7 +246,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { return null; } - Set overriddenMembers = OverridingUtil.getDirectlyOverriddenDeclarations( + Set overriddenMembers = OverrideResolver.getDirectlyOverriddenDeclarations( (CallableMemberDescriptor) descriptor); if (overriddenMembers.size() == 0) { return null; @@ -289,7 +289,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { return; } - Set overriddenMembers = OverridingUtil + Set overriddenMembers = OverrideResolver .getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor); if (overriddenMembers.size() == 0) { return; @@ -334,7 +334,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { return ""; } - Set overriddenMembers = OverridingUtil + Set overriddenMembers = OverrideResolver .getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor); if (overriddenMembers.size() == 0) { return ""; diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java b/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java index b8ba93efa32..37816a91eac 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java @@ -44,7 +44,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; -import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.PackageType; @@ -135,7 +135,7 @@ public class JetRefactoringUtil { final Project project = declaration.getProject(); Map overriddenElementsToDescriptor = ContainerUtil.map2Map( - OverridingUtil.getAllOverriddenDescriptors(declarationDescriptor), + OverrideResolver.getAllOverriddenDescriptors(declarationDescriptor), new Function>() { @Override public Pair fun(CallableDescriptor descriptor) { diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignature.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignature.kt index fed56b8fef7..30ff4ca18a6 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignature.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignature.kt @@ -25,7 +25,6 @@ import com.intellij.openapi.util.Disposer import com.intellij.psi.PsiElement import org.jetbrains.jet.lang.descriptors.* import org.jetbrains.jet.lang.resolve.BindingContext -import org.jetbrains.jet.lang.resolve.OverridingUtil import org.jetbrains.jet.plugin.JetBundle import org.jetbrains.jet.renderer.DescriptorRenderer import java.util.* @@ -35,6 +34,7 @@ import org.jetbrains.jet.plugin.codeInsight.DescriptorToDeclarationUtil import org.jetbrains.jet.plugin.quickfix.QuickFixUtil import com.intellij.CommonBundle import com.intellij.refactoring.RefactoringBundle +import org.jetbrains.jet.lang.resolve.OverrideResolver public trait JetChangeSignatureConfiguration { fun configure(changeSignatureData: JetChangeSignatureData, bindingContext: BindingContext) @@ -70,7 +70,7 @@ public class JetChangeSignature(val project: Project, val closestModifiableDescriptors = getClosestModifiableDescriptors() assert(!closestModifiableDescriptors.isEmpty(), "Should contain functionDescriptor itself or some of its super declarations") - val deepestSuperDeclarations = OverridingUtil.getDeepestSuperDeclarations(functionDescriptor) + val deepestSuperDeclarations = OverrideResolver.getDeepestSuperDeclarations(functionDescriptor) if (ApplicationManager.getApplication()!!.isUnitTestMode()) { showChangeSignatureDialog(deepestSuperDeclarations) return @@ -104,7 +104,7 @@ public class JetChangeSignature(val project: Project, Collections.singleton(functionDescriptor) } DELEGATION, FAKE_OVERRIDE -> { - OverridingUtil.getDirectlyOverriddenDeclarations(functionDescriptor) + OverrideResolver.getDirectlyOverriddenDeclarations(functionDescriptor) } else -> { throw IllegalStateException("Unexpected callable kind: ${functionDescriptor.getKind()}") @@ -229,5 +229,5 @@ TestOnly public fun getChangeSignatureDialog(project: Project, bindingContext: BindingContext, defaultValueContext: PsiElement): JetChangeSignatureDialog? { val jetChangeSignature = JetChangeSignature(project, functionDescriptor, configuration, bindingContext, defaultValueContext, null) - return jetChangeSignature.createChangeSignatureDialog(OverridingUtil.getDeepestSuperDeclarations(functionDescriptor)) + return jetChangeSignature.createChangeSignatureDialog(OverrideResolver.getDeepestSuperDeclarations(functionDescriptor)) } \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinPropertyProcessor.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinPropertyProcessor.kt index 76c29c44c93..7ce8f926b59 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinPropertyProcessor.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinPropertyProcessor.kt @@ -43,6 +43,7 @@ import com.intellij.openapi.ui.Messages import org.jetbrains.jet.lang.resolve.OverridingUtil import org.jetbrains.jet.lang.descriptors.PropertyDescriptor import org.jetbrains.jet.asJava.namedUnwrappedElement +import org.jetbrains.jet.lang.resolve.OverrideResolver public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() { override fun canProcessElement(element: PsiElement): Boolean = element.namedUnwrappedElement is JetProperty @@ -179,7 +180,7 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() { if (descriptor != null) { assert(descriptor is PropertyDescriptor, "Property descriptor is expected") - val supers = OverridingUtil.getDeepestSuperDeclarations(descriptor as PropertyDescriptor) + val supers = OverrideResolver.getDeepestSuperDeclarations(descriptor as PropertyDescriptor) // Take one of supers for now - API doesn't support substitute to several elements (IDEA-48796) val deepest = supers.first() diff --git a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt b/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt index 97d48450dc4..646c37b339b 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt +++ b/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt @@ -16,11 +16,8 @@ package org.jetbrains.jet.plugin.search.usagesSearch -import com.intellij.psi.PsiClass import com.intellij.psi.PsiConstructorCall import com.intellij.psi.PsiElement -import com.intellij.psi.PsiMethod -import com.intellij.psi.util.PsiTreeUtil import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor import org.jetbrains.jet.lang.psi.* @@ -29,21 +26,17 @@ import org.jetbrains.jet.lang.resolve.BindingContext import org.jetbrains.jet.lang.resolve.BindingContextUtils import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache import com.intellij.psi.PsiReference -import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod -import org.jetbrains.jet.lang.resolve.OverridingUtil import org.jetbrains.jet.lang.descriptors.FunctionDescriptor import org.jetbrains.jet.lang.descriptors.ClassDescriptor import org.jetbrains.jet.lang.resolve.DescriptorUtils import org.jetbrains.jet.lang.descriptors.CallableDescriptor import org.jetbrains.jet.plugin.findUsages.JetUsageTypeProvider -import org.jetbrains.jet.plugin.findUsages.JetUsageTypes import com.intellij.usages.impl.rules.UsageType -import org.jetbrains.jet.asJava.LightClassUtil -import org.jetbrains.jet.lang.resolve.java.JvmAbi import org.jetbrains.jet.codegen.PropertyCodegen import org.jetbrains.jet.lang.descriptors.PropertyDescriptor import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod import org.jetbrains.jet.asJava.unwrapped +import org.jetbrains.jet.lang.resolve.OverrideResolver // Navigation element of the resolved reference // For property accessor return enclosing property @@ -151,7 +144,7 @@ fun PsiReference.isCallableOverrideUsage(declaration: JetNamedDeclaration): Bool return checkUsageVsOriginalDescriptor(declaration, decl2Desc) { (usageDescriptor, targetDescriptor) -> usageDescriptor is CallableDescriptor && targetDescriptor is CallableDescriptor - && OverridingUtil.overrides(usageDescriptor, targetDescriptor) + && OverrideResolver.overrides(usageDescriptor, targetDescriptor) } } diff --git a/idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractOverrideImplementTest.java b/idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractOverrideImplementTest.java index 4b86e655596..e92368b66aa 100644 --- a/idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractOverrideImplementTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractOverrideImplementTest.java @@ -38,7 +38,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.psi.JetClassOrObject; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.JetLightProjectDescriptor; import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; @@ -134,7 +134,7 @@ public abstract class AbstractOverrideImplementTest extends LightCodeInsightFixt @Override public Boolean invoke(CallableMemberDescriptor descriptor) { ClassDescriptor any = KotlinBuiltIns.getInstance().getAny(); - for (CallableMemberDescriptor overridden : OverridingUtil.getOverriddenDeclarations(descriptor)) { + for (CallableMemberDescriptor overridden : OverrideResolver.getOverriddenDeclarations(descriptor)) { if (overridden.getContainingDeclaration().equals(any)) { return false; } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/patterns/PatternBuilder.java b/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/patterns/PatternBuilder.java index e1b85c7fd0c..33b7199df1c 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/patterns/PatternBuilder.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/patterns/PatternBuilder.java @@ -20,7 +20,7 @@ import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.k2js.translate.context.Namer; @@ -175,14 +175,14 @@ public final class PatternBuilder { return matches(functionDescriptor); } - for (CallableMemberDescriptor real : OverridingUtil.getOverriddenDeclarations(functionDescriptor)) { + for (CallableMemberDescriptor real : OverrideResolver.getOverriddenDeclarations(functionDescriptor)) { if (matches(real)) { return true; } } if (checkOverridden) { - for (CallableDescriptor overridden : OverridingUtil.getAllOverriddenDescriptors(functionDescriptor)) { + for (CallableDescriptor overridden : OverrideResolver.getAllOverriddenDescriptors(functionDescriptor)) { if (matches(overridden)) { return true; } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/utils/AnnotationsUtils.java b/js/js.translator/src/org/jetbrains/k2js/translate/utils/AnnotationsUtils.java index d87f8de74d9..d59ce0ad91c 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/utils/AnnotationsUtils.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/utils/AnnotationsUtils.java @@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -80,7 +80,7 @@ public final class AnnotationsUtils { isOverride((CallableMemberDescriptor) declarationDescriptor)) { Set overriddenDeclarations = - OverridingUtil.getAllOverriddenDeclarations((CallableMemberDescriptor) declarationDescriptor); + OverrideResolver.getAllOverriddenDeclarations((CallableMemberDescriptor) declarationDescriptor); descriptors = ContainerUtil.mapNotNull(overriddenDeclarations, new Function() { @Override diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/utils/TranslationUtils.java b/js/js.translator/src/org/jetbrains/k2js/translate/utils/TranslationUtils.java index 6555a752d0c..52dc57c13de 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/utils/TranslationUtils.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/utils/TranslationUtils.java @@ -26,7 +26,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.OverridingUtil; +import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.k2js.translate.context.TemporaryConstVariable; @@ -465,7 +465,7 @@ public final class TranslationUtils { private static boolean isNativeOrOverrideNative(FunctionDescriptor descriptor) { if (AnnotationsUtils.isNativeObject(descriptor)) return true; - Set declarations = OverridingUtil.getAllOverriddenDeclarations(descriptor); + Set declarations = OverrideResolver.getAllOverriddenDeclarations(descriptor); for (FunctionDescriptor memberDescriptor : declarations) { if (AnnotationsUtils.isNativeObject(memberDescriptor)) return true; }