Move some utilities from OverridingUtil to OverrideResolver

OverridingUtil will be present at runtime and we should strive to minimize the
size of our runtime classes

Also add a comment to getOverriddenDescriptors()

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 overriddenDeclarations = OverrideResolver.getOverriddenDeclarations(descriptor)
-    val filteredOverriddenDeclarations = OverridingUtil.filterOutOverridden(overriddenDeclarations)
+    val filteredOverriddenDeclarations = OverrideResolver.filterOutOverridden(overriddenDeclarations)
 
     var implementation: CallableMemberDescriptor? = null
     for (overriddenDeclaration in filteredOverriddenDeclarations) {

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())) {

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

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 <D extends CallableDescriptor> Set<D> filterOutOverridden(@NotNull Set<D> candidateSet) {
+        //noinspection unchecked
+        return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDING);
+    }
+
+    @NotNull
+    public static <D> Set<D> filterOutOverriding(@NotNull Set<D> candidateSet) {
+        //noinspection unchecked
+        return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDDEN);
+    }
+
+    @NotNull
+    public static <D> Set<D> filterOutOverridden(
+            @NotNull Set<D> candidateSet,
+            @NotNull Function<? super D, ? extends CallableDescriptor> transform
+    ) {
+        return filterOverrides(candidateSet, transform, Filtering.RETAIN_OVERRIDING);
+    }
+
+    @NotNull
+    private static <D> Set<D> filterOverrides(
+            @NotNull Set<D> candidateSet,
+            @NotNull Function<? super D, ? extends CallableDescriptor> transform,
+            @NotNull Filtering filtering
+    ) {
+        Set<D> 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 <D extends CallableDescriptor> 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<CallableDescriptor> getAllOverriddenDescriptors(@NotNull CallableDescriptor f) {
+        Set<CallableDescriptor> result = new LinkedHashSet<CallableDescriptor>();
+        collectAllOverriddenDescriptors(f.getOriginal(), result);
+        return result;
+    }
+
+    private static void collectAllOverriddenDescriptors(@NotNull CallableDescriptor current, @NotNull Set<CallableDescriptor> result) {
+        if (result.contains(current)) return;
+        for (CallableDescriptor descriptor : current.getOriginal().getOverriddenDescriptors()) {
+            collectAllOverriddenDescriptors(descriptor, result);
+            result.add(descriptor);
+        }
+    }
+
     private static <T extends DeclarationDescriptor> MultiMap<Name, T> groupDescriptorsByName(Collection<T> properties) {
         MultiMap<Name, T> r = new LinkedMultiMap<Name, T>();
         for (T property : properties) {
@@ -278,7 +369,7 @@ public class OverrideResolver {
         Map<CallableMemberDescriptor, Set<CallableMemberDescriptor>> overriddenDeclarationsByDirectParent = collectOverriddenDeclarations(directOverridden);
 
         List<CallableMemberDescriptor> allOverriddenDeclarations = ContainerUtil.flatten(overriddenDeclarationsByDirectParent.values());
-        Set<CallableMemberDescriptor> allFilteredOverriddenDeclarations = OverridingUtil.filterOutOverridden(
+        Set<CallableMemberDescriptor> allFilteredOverriddenDeclarations = filterOutOverridden(
                 Sets.newLinkedHashSet(allOverriddenDeclarations));
 
         Set<CallableMemberDescriptor> relevantDirectlyOverridden =
@@ -384,13 +475,43 @@ public class OverrideResolver {
     ) {
         Map<CallableMemberDescriptor, Set<CallableMemberDescriptor>> overriddenDeclarationsByDirectParent = Maps.newLinkedHashMap();
         for (CallableMemberDescriptor descriptor : directOverriddenDescriptors) {
-            Set<CallableMemberDescriptor> overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(descriptor);
+            Set<CallableMemberDescriptor> overriddenDeclarations = getOverriddenDeclarations(descriptor);
-            Set<CallableMemberDescriptor> filteredOverrides = OverridingUtil.filterOutOverridden(overriddenDeclarations);
+            Set<CallableMemberDescriptor> filteredOverrides = filterOutOverridden(overriddenDeclarations);
             overriddenDeclarationsByDirectParent.put(descriptor, new LinkedHashSet<CallableMemberDescriptor>(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<CallableMemberDescriptor> getOverriddenDeclarations(@NotNull CallableMemberDescriptor descriptor) {
+        Set<CallableMemberDescriptor> result = new LinkedHashSet<CallableMemberDescriptor>();
+        getOverriddenDeclarations(descriptor, result);
+        return result;
+    }
+
+    private static void getOverriddenDeclarations(
+            @NotNull CallableMemberDescriptor descriptor,
+            @NotNull Set<CallableMemberDescriptor> 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<? extends CallableMemberDescriptor> overriddenDescriptors = declared.getOverriddenDescriptors();
 
         for (CallableMemberDescriptor overridden : overriddenDescriptors) {
-            if (overridden != null) {
+            if (overridden == null) continue;
-                if (!overridden.getModality().isOverridable()) {
-                    reportError.overridingFinalMember(overridden);
-                }
 
-                if (declared instanceof PropertyDescriptor && !OverridingUtil.isPropertyTypeOkForOverride(
+            if (!overridden.getModality().isOverridable()) {
-                        JetTypeChecker.INSTANCE, (PropertyDescriptor) overridden, (PropertyDescriptor) declared)) {
+                reportError.overridingFinalMember(overridden);
-                    reportError.propertyTypeMismatchOnOverride(overridden);
+            }
-                }
-                else if (!OverridingUtil.isReturnTypeOkForOverride(JetTypeChecker.INSTANCE, overridden, declared)) {
-                    reportError.returnTypeMismatchOnOverride(overridden);
-                }
 
-                if (checkPropertyKind(overridden, true) && checkPropertyKind(declared, false)) {
+            if (declared instanceof PropertyDescriptor &&
-                    reportError.varOverriddenByVal(overridden);
+                !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<TypeParameterDescriptor> superTypeParameters = superDescriptor.getTypeParameters();
+        List<TypeParameterDescriptor> subTypeParameters = subDescriptor.getTypeParameters();
+        if (subTypeParameters.size() != superTypeParameters.size()) return null;
+
+        Map<TypeConstructor, TypeProjection> 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 <D extends CallableMemberDescriptor> Set<D> getDirectlyOverriddenDeclarations(@NotNull D descriptor) {
+        Set<D> result = Sets.newHashSet();
+        //noinspection unchecked
+        Set<D> overriddenDescriptors = (Set<D>) 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 <D extends CallableMemberDescriptor> Set<D> getAllOverriddenDeclarations(@NotNull D memberDescriptor) {
+        Set<D> 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 <D extends CallableMemberDescriptor> Set<D> getDeepestSuperDeclarations(@NotNull D functionDescriptor) {
+        Set<D> overriddenDeclarations = getAllOverriddenDeclarations(functionDescriptor);
+        if (overriddenDeclarations.isEmpty()) {
+            return Collections.singleton(functionDescriptor);
+        }
+
+        return filterOutOverriding(overriddenDeclarations);
+    }
 }

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 (OverrideResolver.overrides(f, g)) return true;
-        if (OverridingUtil.overrides(g, f)) return false;
+        if (OverrideResolver.overrides(g, f)) return false;
 
         ReceiverParameterDescriptor receiverOfF = f.getReceiverParameter();
         ReceiverParameterDescriptor receiverOfG = g.getReceiverParameter();

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<ResolvedCallWithTrace<D>> noOverrides = OverridingUtil.filterOutOverridden(failedCandidates, MAP_TO_CANDIDATE);
+            Set<ResolvedCallWithTrace<D>> 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<ResolvedCallWithTrace<D>> noOverrides = OverridingUtil.filterOutOverridden(candidates, MAP_TO_RESULT);
+        Set<ResolvedCallWithTrace<D>> noOverrides = OverrideResolver.filterOutOverridden(candidates, MAP_TO_RESULT);
         if (noOverrides.size() == 1) {
                 return OverloadResolutionResultsImpl.success(noOverrides.iterator().next());
         }

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 <D extends CallableDescriptor> Set<D> filterOutOverridden(@NotNull Set<D> candidateSet) {
-        //noinspection unchecked
-        return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDING);
-    }
-
-    @NotNull
-    public static <D> Set<D> filterOutOverriding(@NotNull Set<D> candidateSet) {
-        //noinspection unchecked
-        return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDDEN);
-    }
-
-    @NotNull
-    public static <D> Set<D> filterOutOverridden(
-            @NotNull Set<D> candidateSet,
-            @NotNull Function<? super D, ? extends CallableDescriptor> transform
-    ) {
-        return filterOverrides(candidateSet, transform, Filtering.RETAIN_OVERRIDING);
-    }
-
-    @NotNull
-    private static <D> Set<D> filterOverrides(
-            @NotNull Set<D> candidateSet,
-            @NotNull Function<? super D, ? extends CallableDescriptor> transform,
-            @NotNull Filtering filtering
-    ) {
-        Set<D> 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 <D extends CallableDescriptor> 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<CallableDescriptor> getAllOverriddenDescriptors(CallableDescriptor f) {
-        Set<CallableDescriptor> overriddenDescriptors = Sets.newHashSet();
-        collectAllOverriddenDescriptors(f.getOriginal(), overriddenDescriptors);
-        return overriddenDescriptors;
-    }
-
-    private static void collectAllOverriddenDescriptors(
-            @NotNull CallableDescriptor current,
-            @NotNull Set<CallableDescriptor> 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<TypeParameterDescriptor> superTypeParameters = superDescriptor.getTypeParameters();
-        List<TypeParameterDescriptor> subTypeParameters = subDescriptor.getTypeParameters();
-        if (subTypeParameters.size() != superTypeParameters.size()) return null;
-
-        Map<TypeConstructor, TypeProjection> 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<CallableMemberDescriptor> getOverriddenDeclarations(@NotNull CallableMemberDescriptor descriptor) {
-        Set<CallableMemberDescriptor> result = new LinkedHashSet<CallableMemberDescriptor>();
-        getOverriddenDeclarations(descriptor, result);
-        return result;
-    }
-
-    private static void getOverriddenDeclarations(
-            @NotNull CallableMemberDescriptor descriptor,
-            @NotNull Set<CallableMemberDescriptor> 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<CallableMemberDescriptor> getDirectlyOverriddenDeclarations(@NotNull CallableMemberDescriptor descriptor) {
-        Set<CallableMemberDescriptor> result = Sets.newHashSet();
-        Set<? extends CallableMemberDescriptor> 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<FunctionDescriptor> getDirectlyOverriddenDeclarations(@NotNull FunctionDescriptor descriptor) {
-        //noinspection unchecked
-        return (Set) getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor);
-    }
-
-    @NotNull
-    public static Set<PropertyDescriptor> getDirectlyOverriddenDeclarations(@NotNull PropertyDescriptor descriptor) {
-        //noinspection unchecked
-        return (Set) getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor);
-    }
-
-    @NotNull
-    public static <T extends CallableMemberDescriptor> Set<T> getAllOverriddenDeclarations(@NotNull T memberDescriptor) {
-        Set<T> 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 <T extends CallableMemberDescriptor> Set<T> getDeepestSuperDeclarations(T functionDescriptor) {
-        Set<T> overriddenDeclarations = getAllOverriddenDeclarations(functionDescriptor);
-        if (overriddenDeclarations.isEmpty()) {
-            return Collections.singleton(functionDescriptor);
-        }
-
-        return filterOutOverriding(overriddenDeclarations);
-    }
 }

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");
             }

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<CallableMemberDescriptor> filteredMembers = OverridingUtil.filterOutOverridden(inheritedFunctions);
+        Set<CallableMemberDescriptor> filteredMembers = OverrideResolver.filterOutOverridden(inheritedFunctions);
 
         // Group members with "the same" signature
         Multimap<CallableMemberDescriptor, CallableMemberDescriptor> factoredMembers = LinkedHashMultimap.create();

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<? extends CallableMemberDescriptor> overriddenMembers = OverridingUtil.getDirectlyOverriddenDeclarations(
+        Set<? extends CallableMemberDescriptor> overriddenMembers = OverrideResolver.getDirectlyOverriddenDeclarations(
                 (CallableMemberDescriptor) descriptor);
         if (overriddenMembers.size() == 0) {
             return null;
@@ -289,7 +289,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
             return;
         }
 
-        Set<CallableMemberDescriptor> overriddenMembers = OverridingUtil
+        Set<CallableMemberDescriptor> overriddenMembers = OverrideResolver
                 .getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor);
         if (overriddenMembers.size() == 0) {
             return;
@@ -334,7 +334,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
             return "";
         }
 
-        Set<CallableMemberDescriptor> overriddenMembers = OverridingUtil
+        Set<CallableMemberDescriptor> overriddenMembers = OverrideResolver
                 .getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor);
         if (overriddenMembers.size() == 0) {
             return "";

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<PsiElement, CallableDescriptor> overriddenElementsToDescriptor = ContainerUtil.map2Map(
-                OverridingUtil.getAllOverriddenDescriptors(declarationDescriptor),
+                OverrideResolver.getAllOverriddenDescriptors(declarationDescriptor),
                 new Function<CallableDescriptor, Pair<PsiElement, CallableDescriptor>>() {
                     @Override
                     public Pair<PsiElement, CallableDescriptor> fun(CallableDescriptor descriptor) {

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))
 }

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()

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)
     }
 }
 

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;
                         }

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;
                     }

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<CallableMemberDescriptor> overriddenDeclarations =
-                    OverridingUtil.getAllOverriddenDeclarations((CallableMemberDescriptor) declarationDescriptor);
+                    OverrideResolver.getAllOverriddenDeclarations((CallableMemberDescriptor) declarationDescriptor);
 
             descriptors = ContainerUtil.mapNotNull(overriddenDeclarations, new Function<CallableMemberDescriptor, DeclarationDescriptor>() {
                 @Override

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<FunctionDescriptor> declarations = OverridingUtil.getAllOverriddenDeclarations(descriptor);
+            Set<FunctionDescriptor> declarations = OverrideResolver.getAllOverriddenDeclarations(descriptor);
             for (FunctionDescriptor memberDescriptor : declarations) {
                 if (AnnotationsUtils.isNativeObject(memberDescriptor)) return true;
             }