Refactor: Move and rename OverridingUtil.DescriptorSink -> OverridingStrategy

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

@@ -20,12 +20,11 @@ import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.SpecialSignatureInfo
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.getSpecialSignatureInfo
 import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.isBuiltinWithSpecialDescriptorInJvm
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.OverrideResolver
-import org.jetbrains.kotlin.resolve.OverridingUtil
+import org.jetbrains.kotlin.resolve.OverridingStrategy
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
@@ -33,9 +32,7 @@ import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.org.objectweb.asm.Opcodes.*
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
-import java.util.ArrayList
+import java.util.*
-import java.util.HashSet
-import java.util.LinkedHashSet
 
 /**
  * Generates exception-throwing stubs for methods from mutable collection classes not implemented in Kotlin classes which inherit only from
@@ -194,7 +191,7 @@ class CollectionStubMethodGenerator(
     ): List<FunctionDescriptor> {
         val result = ArrayList<FunctionDescriptor>()
 
-        OverrideResolver.generateOverridesInAClass(klass, listOf(), object : OverridingUtil.DescriptorSink {
+        OverrideResolver.generateOverridesInAClass(klass, listOf(), object : OverridingStrategy {
             override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) {
                 if (fakeOverride !is FunctionDescriptor) return
                 if (fakeOverride.findOverriddenFromDirectSuperClass(mutableCollectionClass)?.kind == DECLARATION) {

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

@@ -69,7 +69,7 @@ public class OverrideResolver {
     public static void generateOverridesInAClass(
             @NotNull ClassDescriptor classDescriptor,
             @NotNull Collection<CallableMemberDescriptor> membersFromCurrent,
-            @NotNull OverridingUtil.DescriptorSink sink
+            @NotNull OverridingStrategy strategy
     ) {
         List<CallableMemberDescriptor> membersFromSupertypes = getCallableMembersFromSupertypes(classDescriptor);
         MultiMap<Name, CallableMemberDescriptor> membersFromCurrentByName = groupDescriptorsByName(membersFromCurrent);
@@ -83,7 +83,7 @@ public class OverrideResolver {
             Collection<CallableMemberDescriptor> fromSupertypes = membersFromSupertypesByName.get(memberName);
             Collection<CallableMemberDescriptor> fromCurrent = membersFromCurrentByName.get(memberName);
 
-            OverridingUtil.generateOverridesInFunctionGroup(memberName, fromSupertypes, fromCurrent, classDescriptor, sink);
+            OverridingUtil.generateOverridesInFunctionGroup(memberName, fromSupertypes, fromCurrent, classDescriptor, strategy);
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt

@@ -99,7 +99,7 @@ open class LazyClassMemberScope(
     }
 
     private fun <D : CallableMemberDescriptor> generateFakeOverrides(name: Name, fromSupertypes: Collection<D>, result: MutableCollection<D>, exactDescriptorClass: Class<out D>) {
-        OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, ArrayList(result), thisDescriptor, object : OverridingUtil.DescriptorSink {
+        OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, ArrayList(result), thisDescriptor, object : OverridingStrategy {
             override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) {
                 assert(exactDescriptorClass.isInstance(fakeOverride)) { "Wrong descriptor type in an override: " + fakeOverride + " while expecting " + exactDescriptorClass.simpleName }
                 @Suppress("UNCHECKED_CAST")

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.load.java.structure.*;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.resolve.OverridingStrategy;
 import org.jetbrains.kotlin.resolve.OverridingUtil;
 import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter;
 
@@ -48,7 +49,7 @@ public final class DescriptorResolverUtils {
 
         OverridingUtil.generateOverridesInFunctionGroup(
                 name, membersFromSupertypes, membersFromCurrent, classDescriptor,
-                new OverridingUtil.DescriptorSink() {
+                new OverridingStrategy() {
                     @Override
                     @SuppressWarnings("unchecked")
                     public void addFakeOverride(@NotNull CallableMemberDescriptor fakeOverride) {

core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScopeImpl
 import org.jetbrains.kotlin.incremental.components.LookupLocation
+import org.jetbrains.kotlin.resolve.OverridingStrategy
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.toReadOnlyList
@@ -66,7 +67,7 @@ class FunctionClassScope(
                         /* membersFromSupertypes = */ descriptors,
                         /* membersFromCurrent = */ if (isFunction && name == invoke?.name) listOf(invoke) else listOf(),
                         functionClass,
-                        object : OverridingUtil.DescriptorSink {
+                        object : OverridingStrategy {
                             override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) {
                                 OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, null)
                                 result.add(fakeOverride)

core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.incremental.components.LookupLocation;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.DescriptorFactory;
+import org.jetbrains.kotlin.resolve.OverridingStrategy;
 import org.jetbrains.kotlin.resolve.OverridingUtil;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.kotlin.resolve.scopes.MemberScope;
@@ -245,7 +246,7 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase {
 
             OverridingUtil.generateOverridesInFunctionGroup(
                     name, fromSupertypes, Collections.<D>emptySet(), EnumEntrySyntheticClassDescriptor.this,
-                    new OverridingUtil.DescriptorSink() {
+                    new OverridingStrategy() {
                         @Override
                         @SuppressWarnings("unchecked")
                         public void addFakeOverride(@NotNull CallableMemberDescriptor fakeOverride) {

core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingStrategy.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.resolve
+
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+
+interface OverridingStrategy {
+    fun addFakeOverride(fakeOverride: CallableMemberDescriptor)
+
+    fun conflict(fromSuper: CallableMemberDescriptor, fromCurrent: CallableMemberDescriptor)
+}

core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java

@@ -16,8 +16,8 @@
 
 package org.jetbrains.kotlin.resolve;
 
-import kotlin.collections.CollectionsKt;
 import kotlin.Unit;
+import kotlin.collections.CollectionsKt;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.Mutable;
 import org.jetbrains.annotations.NotNull;
@@ -274,24 +274,24 @@ public class OverridingUtil {
             @NotNull Collection<? extends CallableMemberDescriptor> membersFromSupertypes,
             @NotNull Collection<? extends CallableMemberDescriptor> membersFromCurrent,
             @NotNull ClassDescriptor current,
-            @NotNull DescriptorSink sink
+            @NotNull OverridingStrategy strategy
     ) {
         Collection<CallableMemberDescriptor> notOverridden = new LinkedHashSet<CallableMemberDescriptor>(membersFromSupertypes);
 
         for (CallableMemberDescriptor fromCurrent : membersFromCurrent) {
             Collection<CallableMemberDescriptor> bound =
-                    extractAndBindOverridesForMember(fromCurrent, membersFromSupertypes, current, sink);
+                    extractAndBindOverridesForMember(fromCurrent, membersFromSupertypes, current, strategy);
             notOverridden.removeAll(bound);
         }
 
-        createAndBindFakeOverrides(current, notOverridden, sink);
+        createAndBindFakeOverrides(current, notOverridden, strategy);
     }
 
     private static Collection<CallableMemberDescriptor> extractAndBindOverridesForMember(
             @NotNull CallableMemberDescriptor fromCurrent,
             @NotNull Collection<? extends CallableMemberDescriptor> descriptorsFromSuper,
             @NotNull ClassDescriptor current,
-            @NotNull DescriptorSink sink
+            @NotNull OverridingStrategy strategy
     ) {
         Collection<CallableMemberDescriptor> bound = new ArrayList<CallableMemberDescriptor>(descriptorsFromSuper.size());
         Collection<CallableMemberDescriptor> overridden = SmartSet.create();
@@ -308,7 +308,7 @@ public class OverridingUtil {
                     break;
                 case CONFLICT:
                     if (isVisible) {
-                        sink.conflict(fromSupertype, fromCurrent);
+                        strategy.conflict(fromSupertype, fromCurrent);
                     }
                     bound.add(fromSupertype);
                     break;
@@ -337,13 +337,13 @@ public class OverridingUtil {
     private static void createAndBindFakeOverrides(
             @NotNull ClassDescriptor current,
             @NotNull Collection<CallableMemberDescriptor> notOverridden,
-            @NotNull DescriptorSink sink
+            @NotNull OverridingStrategy strategy
     ) {
         // Optimization: If all notOverridden descriptors have the same containing declaration,
         // then we can just create fake overrides for them, because they should be matched correctly in their containing declaration
         if (allHasSameContainingDeclaration(notOverridden)) {
             for (CallableMemberDescriptor descriptor : notOverridden) {
-                createAndBindFakeOverride(Collections.singleton(descriptor), current, sink);
+                createAndBindFakeOverride(Collections.singleton(descriptor), current, strategy);
             }
             return;
         }
@@ -352,8 +352,8 @@ public class OverridingUtil {
         while (!fromSuperQueue.isEmpty()) {
             CallableMemberDescriptor notOverriddenFromSuper = VisibilityUtilKt.findMemberWithMaxVisibility(fromSuperQueue);
             Collection<CallableMemberDescriptor> overridables =
-                    extractMembersOverridableInBothWays(notOverriddenFromSuper, fromSuperQueue, sink);
+                    extractMembersOverridableInBothWays(notOverriddenFromSuper, fromSuperQueue, strategy);
-            createAndBindFakeOverride(overridables, current, sink);
+            createAndBindFakeOverride(overridables, current, strategy);
         }
     }
 
@@ -476,7 +476,7 @@ public class OverridingUtil {
     private static void createAndBindFakeOverride(
             @NotNull Collection<CallableMemberDescriptor> overridables,
             @NotNull ClassDescriptor current,
-            @NotNull DescriptorSink sink
+            @NotNull OverridingStrategy strategy
     ) {
         Collection<CallableMemberDescriptor> visibleOverridables = filterVisibleFakeOverrides(current, overridables);
         boolean allInvisible = visibleOverridables.isEmpty();
@@ -502,7 +502,7 @@ public class OverridingUtil {
         CallableMemberDescriptor fakeOverride =
                 mostSpecific.copy(current, modality, visibility, CallableMemberDescriptor.Kind.FAKE_OVERRIDE, false);
         fakeOverride.setOverriddenDescriptors(effectiveOverridden);
-        sink.addFakeOverride(fakeOverride);
+        strategy.addFakeOverride(fakeOverride);
     }
 
     @NotNull
@@ -584,7 +584,7 @@ public class OverridingUtil {
     private static Collection<CallableMemberDescriptor> extractMembersOverridableInBothWays(
             @NotNull final CallableMemberDescriptor overrider,
             @NotNull Queue<CallableMemberDescriptor> extractFrom,
-            @NotNull final DescriptorSink sink
+            @NotNull final OverridingStrategy strategy
     ) {
         return extractMembersOverridableInBothWays(overrider, extractFrom,
                 // ID
@@ -597,7 +597,7 @@ public class OverridingUtil {
                 new Function1<CallableMemberDescriptor, Unit>() {
                     @Override
                     public Unit invoke(CallableMemberDescriptor descriptor) {
-                        sink.conflict(overrider, descriptor);
+                        strategy.conflict(overrider, descriptor);
                         return Unit.INSTANCE;
                     }
                 });
@@ -698,12 +698,6 @@ public class OverridingUtil {
         return maxVisibility;
     }
 
-    public interface DescriptorSink {
-        void addFakeOverride(@NotNull CallableMemberDescriptor fakeOverride);
-
-        void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent);
-    }
-
     public static class OverrideCompatibilityInfo {
         public enum Result {
             OVERRIDABLE,

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorFactory
+import org.jetbrains.kotlin.resolve.OverridingStrategy
 import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
@@ -219,7 +220,7 @@ class DeserializedClassDescriptor(
 
         private fun <D : CallableMemberDescriptor> generateFakeOverrides(name: Name, fromSupertypes: Collection<D>, result: MutableCollection<D>) {
             val fromCurrent = ArrayList<CallableMemberDescriptor>(result)
-            OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, fromCurrent, classDescriptor, object : OverridingUtil.DescriptorSink {
+            OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, fromCurrent, classDescriptor, object : OverridingStrategy {
                 override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) {
                     // TODO: report "cannot infer visibility"
                     OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, null)