Use platform-dependent filter for callable package members

before checking for overloads:
filter deserialized callable package members by implementation class files
for callable package members from source.

 #KT-10051 Fixed

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmOverloadFilter.kt

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2010-2015 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.jvm
+
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
+import org.jetbrains.kotlin.fileClasses.NoResolveFileClassesProvider
+import org.jetbrains.kotlin.fileClasses.getFileClassFqName
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.resolve.OverloadFilter
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor
+import java.util.*
+
+
+object JvmOverloadFilter : OverloadFilter {
+    override fun filterPackageMemberOverloads(overloads: Collection<CallableMemberDescriptor>): Collection<CallableMemberDescriptor> {
+        val result = ArrayList<CallableMemberDescriptor>()
+
+        val sourceClassesFQNs = HashSet<FqName>()
+        for (overload in overloads) {
+            val file = DescriptorToSourceUtils.getContainingFile(overload) ?: continue
+            result.add(overload)
+            sourceClassesFQNs.add(NoResolveFileClassesProvider.getFileClassFqName(file))
+        }
+
+        for (overload in overloads) {
+            if (overload !is DeserializedCallableMemberDescriptor) continue
+
+            val containingDeclaration = overload.containingDeclaration
+            if (containingDeclaration !is PackageFragmentDescriptor) {
+                throw AssertionError("Package member expected; got $overload with containing declaration $containingDeclaration")
+            }
+            val implClassName = JvmFileClassUtil.getImplClassName(overload) ?:
+                                throw AssertionError("No implClassName: $overload")
+            val implClassFQN = containingDeclaration.fqName.child(implClassName)
+            if (!sourceClassesFQNs.contains(implClassFQN)) {
+                result.add(overload)
+            }
+        }
+
+        return result
+    }
+}

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.jvm.RuntimeAssertionsTypeChecker
 import org.jetbrains.kotlin.load.kotlin.JavaAnnotationCallChecker
 import org.jetbrains.kotlin.load.kotlin.nativeDeclarations.NativeFunChecker
 import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.jvm.JvmOverloadFilter
 import org.jetbrains.kotlin.resolve.jvm.checkers.*
 import org.jetbrains.kotlin.types.DynamicTypesSettings
 
@@ -61,7 +62,9 @@ public object JvmPlatformConfigurator : PlatformConfigurator(
                 FileClassAnnotationsChecker
         ),
 
-        identifierChecker = JvmSimpleNameBacktickChecker
+        identifierChecker = JvmSimpleNameBacktickChecker,
+
+        overloadFilter = JvmOverloadFilter
 ) {
 
     override fun configure(container: StorageComponentContainer) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadFilter.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2015 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 OverloadFilter {
+    fun filterPackageMemberOverloads(overloads: Collection<CallableMemberDescriptor>): Collection<CallableMemberDescriptor>
+
+    object DEFAULT : OverloadFilter {
+        override fun filterPackageMemberOverloads(overloads: Collection<CallableMemberDescriptor>): Collection<CallableMemberDescriptor> =
+                overloads
+    }
+}

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

@@ -35,10 +35,16 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.getFqName;
 
 public class OverloadResolver {
     @NotNull private final BindingTrace trace;
+    @NotNull private final OverloadFilter overloadFilter;
     @NotNull private final MainFunctionDetector mainFunctionDetector;
 
-    public OverloadResolver(@NotNull BindingTrace trace) {
+    public OverloadResolver(
+            @NotNull BindingTrace trace,
+            @NotNull OverloadFilter overloadFilter
+    ) {
         this.trace = trace;
+        this.overloadFilter = overloadFilter;
+
         mainFunctionDetector = new MainFunctionDetector(trace.getBindingContext());
     }
 
@@ -88,7 +94,8 @@ public class OverloadResolver {
             @NotNull BodiesResolveContext c,
             @NotNull MultiMap<FqNameUnsafe, ConstructorDescriptor> inPackages
     ) {
-        MultiMap<FqNameUnsafe, CallableMemberDescriptor> membersByName = OverloadUtil.groupModulePackageMembersByFqName(c, inPackages);
+        MultiMap<FqNameUnsafe, CallableMemberDescriptor> membersByName =
+                OverloadUtil.groupModulePackageMembersByFqName(c, inPackages, overloadFilter);
 
         for (Map.Entry<FqNameUnsafe, Collection<CallableMemberDescriptor>> e : membersByName.entrySet()) {
             FqNameUnsafe fqName = e.getKey().parent();

compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadUtil.kt

@@ -82,16 +82,17 @@ object OverloadUtil {
 
     public @JvmStatic fun groupModulePackageMembersByFqName(
             c: BodiesResolveContext,
-            constructorsInPackages: MultiMap<FqNameUnsafe, ConstructorDescriptor>
+            constructorsInPackages: MultiMap<FqNameUnsafe, ConstructorDescriptor>,
+            overloadFilter: OverloadFilter
     ): MultiMap<FqNameUnsafe, CallableMemberDescriptor> {
         val packageMembersByName = MultiMap<FqNameUnsafe, CallableMemberDescriptor>()
 
-        collectModulePackageMembersWithSameName(packageMembersByName, c.functions.values) {
+        collectModulePackageMembersWithSameName(packageMembersByName, c.functions.values, overloadFilter) {
             scope, name ->
             scope.getContributedFunctions(name, NoLookupLocation.WHEN_CHECK_REDECLARATIONS)
         }
 
-        collectModulePackageMembersWithSameName(packageMembersByName, c.properties.values) {
+        collectModulePackageMembersWithSameName(packageMembersByName, c.properties.values, overloadFilter) {
             scope, name ->
             scope.getContributedVariables(name, NoLookupLocation.WHEN_CHECK_REDECLARATIONS).filterIsInstance<CallableMemberDescriptor>()
         }
@@ -105,6 +106,7 @@ object OverloadUtil {
     private inline fun collectModulePackageMembersWithSameName(
             packageMembersByName: MultiMap<FqNameUnsafe, CallableMemberDescriptor>,
             interestingDescriptors: Collection<CallableMemberDescriptor>,
+            overloadFilter: OverloadFilter,
             getMembersByName: (MemberScope, Name) -> Collection<CallableMemberDescriptor>
     ) {
         val observedFQNs = hashSetOf<FqNameUnsafe>()
@@ -115,13 +117,14 @@ object OverloadUtil {
             if (observedFQNs.contains(descriptorFQN)) continue
             observedFQNs.add(descriptorFQN)
 
-            val packageMembersWithSameName = getModulePackageMembersWithSameName(descriptor, getMembersByName)
+            val packageMembersWithSameName = getModulePackageMembersWithSameName(descriptor, overloadFilter, getMembersByName)
             packageMembersByName.putValues(descriptorFQN, packageMembersWithSameName)
         }
     }
 
     private inline fun getModulePackageMembersWithSameName(
             packageMember: CallableMemberDescriptor,
+            overloadFilter: OverloadFilter,
             getMembersByName: (MemberScope, Name) -> Collection<CallableMemberDescriptor>
     ): Collection<CallableMemberDescriptor> {
         val containingPackage = packageMember.containingDeclaration
@@ -132,10 +135,13 @@ object OverloadUtil {
         val containingModule = DescriptorUtils.getContainingModuleOrNull(packageMember) ?: return listOf(packageMember)
 
         val containingPackageScope = containingModule.getPackage(containingPackage.fqName).memberScope
-        val possibleOverloads = getMembersByName(containingPackageScope, packageMember.name)
+        val possibleOverloads =
+                getMembersByName(containingPackageScope, packageMember.name).filter {
+                    // NB memberScope for PackageViewDescriptor includes module dependencies
+                    DescriptorUtils.getContainingModule(it) == containingModule
+                }
 
-        // NB memberScope for PackageViewDescriptor includes module dependencies
+        return overloadFilter.filterPackageMemberOverloads(possibleOverloads)
-        return possibleOverloads.filter { DescriptorUtils.getContainingModule(it) == containingModule }
     }
 
     private fun MemberDescriptor.isPrivate() = Visibilities.isPrivate(this.visibility)

compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt

@@ -44,7 +44,8 @@ abstract class TargetPlatform(
         override val builtIns: KotlinBuiltIns
             get() = DefaultBuiltIns.Instance
         override val defaultModuleParameters = ModuleParameters.Empty
-        override val platformConfigurator = PlatformConfigurator(DynamicTypesSettings(), listOf(), listOf(), listOf(), listOf(), listOf(), IdentifierChecker.DEFAULT)
+        override val platformConfigurator = PlatformConfigurator(DynamicTypesSettings(), listOf(), listOf(), listOf(), listOf(), listOf(),
+                                                                 IdentifierChecker.DEFAULT, OverloadFilter.DEFAULT)
     }
 }
 
@@ -69,7 +70,8 @@ open class PlatformConfigurator(
         additionalTypeCheckers: List<AdditionalTypeChecker>,
         additionalSymbolUsageValidators: List<SymbolUsageValidator>,
         private val additionalAnnotationCheckers: List<AdditionalAnnotationChecker>,
-        private val identifierChecker: IdentifierChecker
+        private val identifierChecker: IdentifierChecker,
+        private val overloadFilter: OverloadFilter
 ) {
 
     private val declarationCheckers: List<DeclarationChecker> = DEFAULT_DECLARATION_CHECKERS + additionalDeclarationCheckers
@@ -86,6 +88,7 @@ open class PlatformConfigurator(
             useInstance(symbolUsageValidator)
             additionalAnnotationCheckers.forEach { useInstance(it) }
             useInstance(identifierChecker)
+            useInstance(overloadFilter)
         }
     }
 }

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.js.resolve.diagnostics.JsCallChecker
 import org.jetbrains.kotlin.resolve.IdentifierChecker
+import org.jetbrains.kotlin.resolve.OverloadFilter
 import org.jetbrains.kotlin.resolve.PlatformConfigurator
 import org.jetbrains.kotlin.types.DynamicTypesAllowed
 
@@ -30,7 +31,8 @@ public object JsPlatformConfigurator : PlatformConfigurator(
         additionalTypeCheckers = listOf(),
         additionalSymbolUsageValidators = listOf(),
         additionalAnnotationCheckers = listOf(),
-        identifierChecker = IdentifierChecker.DEFAULT
+        identifierChecker = IdentifierChecker.DEFAULT,
+        overloadFilter = OverloadFilter.DEFAULT
 ) {
     override fun configure(container: StorageComponentContainer) {
         super.configure(container)