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

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