Move OverrideResolver#generateOverridesInAClass to CollectionStubMethodGenerator

Also simplify substantially

compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt

@@ -26,8 +26,10 @@ import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.
 import org.jetbrains.kotlin.load.java.isFromBuiltins
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
+import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.NonReportingOverrideStrategy
-import org.jetbrains.kotlin.resolve.OverrideResolver
+import org.jetbrains.kotlin.resolve.OverridingStrategy
+import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
 import org.jetbrains.kotlin.resolve.descriptorUtil.overriddenTreeUniqueAsSequence
@@ -206,7 +208,7 @@ class CollectionStubMethodGenerator(
     ): List<FunctionDescriptor> {
         val result = ArrayList<FunctionDescriptor>()
 
-        OverrideResolver.generateOverridesInAClass(klass, listOf(), object : NonReportingOverrideStrategy() {
+        generateOverridesInAClass(klass, object : NonReportingOverrideStrategy() {
             override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) {
                 if (fakeOverride !is FunctionDescriptor) return
                 val foundOverriddenFromDirectSuperClass = fakeOverride.findOverriddenFromDirectSuperClass(mutableCollectionClass) ?: return
@@ -262,6 +264,20 @@ class CollectionStubMethodGenerator(
         }
     }
 
+    private fun generateOverridesInAClass(classDescriptor: ClassDescriptor, strategy: OverridingStrategy) {
+        @Suppress("UNCHECKED_CAST")
+        val membersFromSupertypesByName =
+                classDescriptor.typeConstructor.supertypes.flatMapTo(linkedSetOf()) { type ->
+                    DescriptorUtils.getAllDescriptors(type.memberScope).filter {
+                        it is PropertyDescriptor || it is SimpleFunctionDescriptor
+                    } as List<CallableMemberDescriptor>
+                }.groupBy { it.name }
+
+        for ((name, fromSupertypes) in membersFromSupertypesByName) {
+            OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, emptyList(), classDescriptor, strategy)
+        }
+    }
+
     private fun createSyntheticSubclass(): Pair<MutableClassDescriptor, List<TypeParameterDescriptor>> {
         val child = MutableClassDescriptor(descriptor.containingDeclaration, ClassKind.CLASS, false,
                                            Name.special("<synthetic inheritor of ${descriptor.name}>"), descriptor.source)

compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java

@@ -16,14 +16,11 @@
 
 package org.jetbrains.kotlin.resolve;
 
-import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import com.intellij.psi.PsiElement;
 import com.intellij.util.SmartList;
 import com.intellij.util.containers.ContainerUtil;
-import com.intellij.util.containers.LinkedMultiMap;
-import com.intellij.util.containers.MultiMap;
 import com.intellij.util.containers.SmartHashSet;
 import com.intellij.util.containers.hash.EqualityPolicy;
 import kotlin.Unit;
@@ -37,7 +34,6 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticFactory2;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactoryWithPsiElement;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.lexer.KtTokens;
-import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilKt;
 import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsKt;
@@ -68,27 +64,6 @@ public class OverrideResolver {
         checkParameterOverridesForAllClasses(c);
     }
 
-    public static void generateOverridesInAClass(
-            @NotNull ClassDescriptor classDescriptor,
-            @NotNull Collection<CallableMemberDescriptor> membersFromCurrent,
-            @NotNull OverridingStrategy strategy
-    ) {
-        List<CallableMemberDescriptor> membersFromSupertypes = getCallableMembersFromSupertypes(classDescriptor);
-        MultiMap<Name, CallableMemberDescriptor> membersFromCurrentByName = groupDescriptorsByName(membersFromCurrent);
-        MultiMap<Name, CallableMemberDescriptor> membersFromSupertypesByName = groupDescriptorsByName(membersFromSupertypes);
-
-        Set<Name> memberNames = new LinkedHashSet<Name>();
-        memberNames.addAll(membersFromSupertypesByName.keySet());
-        memberNames.addAll(membersFromCurrentByName.keySet());
-
-        for (Name memberName : memberNames) {
-            Collection<CallableMemberDescriptor> fromSupertypes = membersFromSupertypesByName.get(memberName);
-            Collection<CallableMemberDescriptor> fromCurrent = membersFromCurrentByName.get(memberName);
-
-            OverridingUtil.generateOverridesInFunctionGroup(memberName, fromSupertypes, fromCurrent, classDescriptor, strategy);
-        }
-    }
-
     public static void resolveUnknownVisibilities(
             @NotNull Collection<? extends CallableMemberDescriptor> descriptors,
             @NotNull BindingTrace trace
@@ -218,32 +193,6 @@ public class OverrideResolver {
         return false;
     }
 
-    private static <T extends DeclarationDescriptor> MultiMap<Name, T> groupDescriptorsByName(Collection<T> properties) {
-        MultiMap<Name, T> r = new LinkedMultiMap<Name, T>();
-        for (T property : properties) {
-            r.putValue(property.getName(), property);
-        }
-        return r;
-    }
-
-
-    private static List<CallableMemberDescriptor> getCallableMembersFromSupertypes(ClassDescriptor classDescriptor) {
-        Set<CallableMemberDescriptor> r = Sets.newLinkedHashSet();
-        for (KotlinType supertype : classDescriptor.getTypeConstructor().getSupertypes()) {
-            r.addAll(getCallableMembersFromType(supertype));
-        }
-        return new ArrayList<CallableMemberDescriptor>(r);
-    }
-
-    private static List<CallableMemberDescriptor> getCallableMembersFromType(KotlinType type) {
-        List<CallableMemberDescriptor> r = Lists.newArrayList();
-        for (DeclarationDescriptor decl : DescriptorUtils.getAllDescriptors(type.getMemberScope())) {
-            if (decl instanceof PropertyDescriptor || decl instanceof SimpleFunctionDescriptor) {
-                r.add((CallableMemberDescriptor) decl);
-            }
-        }
-        return r;
-    }
 
     private void checkOverrides(@NotNull TopDownAnalysisContext c) {
         for (Map.Entry<KtClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {