diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt index 042eb20f527..fac58b412fa 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt +++ b/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.HashSet -import java.util.LinkedHashSet +import java.util.* /** * 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 { val result = ArrayList() - 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) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java index afd98bd3f60..20469d4a161 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java +++ b/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 membersFromCurrent, - @NotNull OverridingUtil.DescriptorSink sink + @NotNull OverridingStrategy strategy ) { List membersFromSupertypes = getCallableMembersFromSupertypes(classDescriptor); MultiMap membersFromCurrentByName = groupDescriptorsByName(membersFromCurrent); @@ -83,7 +83,7 @@ public class OverrideResolver { Collection fromSupertypes = membersFromSupertypesByName.get(memberName); Collection fromCurrent = membersFromCurrentByName.get(memberName); - OverridingUtil.generateOverridesInFunctionGroup(memberName, fromSupertypes, fromCurrent, classDescriptor, sink); + OverridingUtil.generateOverridesInFunctionGroup(memberName, fromSupertypes, fromCurrent, classDescriptor, strategy); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt index 1837e8cbb6b..0bfe7a8cabb 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt @@ -99,7 +99,7 @@ open class LazyClassMemberScope( } private fun generateFakeOverrides(name: Name, fromSupertypes: Collection, result: MutableCollection, exactDescriptorClass: Class) { - 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") diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java index 737c3ac1cd4..3abdbca6c93 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java +++ b/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) { diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt index 2a8f414f7f8..ac9a2bd6b13 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt +++ b/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) diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java index 9ec108dd98d..a672b25ec3d 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java +++ b/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.emptySet(), EnumEntrySyntheticClassDescriptor.this, - new OverridingUtil.DescriptorSink() { + new OverridingStrategy() { @Override @SuppressWarnings("unchecked") public void addFakeOverride(@NotNull CallableMemberDescriptor fakeOverride) { diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingStrategy.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingStrategy.kt new file mode 100644 index 00000000000..29a966e1c6c --- /dev/null +++ b/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) +} \ No newline at end of file diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java index 7a8197bf96b..7462bd55001 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java +++ b/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 membersFromSupertypes, @NotNull Collection membersFromCurrent, @NotNull ClassDescriptor current, - @NotNull DescriptorSink sink + @NotNull OverridingStrategy strategy ) { Collection notOverridden = new LinkedHashSet(membersFromSupertypes); for (CallableMemberDescriptor fromCurrent : membersFromCurrent) { Collection 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 extractAndBindOverridesForMember( @NotNull CallableMemberDescriptor fromCurrent, @NotNull Collection descriptorsFromSuper, @NotNull ClassDescriptor current, - @NotNull DescriptorSink sink + @NotNull OverridingStrategy strategy ) { Collection bound = new ArrayList(descriptorsFromSuper.size()); Collection 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 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 overridables = - extractMembersOverridableInBothWays(notOverriddenFromSuper, fromSuperQueue, sink); - createAndBindFakeOverride(overridables, current, sink); + extractMembersOverridableInBothWays(notOverriddenFromSuper, fromSuperQueue, strategy); + createAndBindFakeOverride(overridables, current, strategy); } } @@ -476,7 +476,7 @@ public class OverridingUtil { private static void createAndBindFakeOverride( @NotNull Collection overridables, @NotNull ClassDescriptor current, - @NotNull DescriptorSink sink + @NotNull OverridingStrategy strategy ) { Collection 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 extractMembersOverridableInBothWays( @NotNull final CallableMemberDescriptor overrider, @NotNull Queue extractFrom, - @NotNull final DescriptorSink sink + @NotNull final OverridingStrategy strategy ) { return extractMembersOverridableInBothWays(overrider, extractFrom, // ID @@ -597,7 +597,7 @@ public class OverridingUtil { new Function1() { @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, diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt index c63e926c3f8..3f5c8103f79 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt +++ b/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 generateFakeOverrides(name: Name, fromSupertypes: Collection, result: MutableCollection) { val fromCurrent = ArrayList(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)