PackageFacadeProvider refactoring

compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java

@@ -246,6 +246,7 @@ public class JvmCodegenUtil {
                DescriptorUtils.isAnnotationClass(descriptor);
     }
 
+    @NotNull
     public static String getModuleName(ModuleDescriptor module) {
         return KotlinPackage.removeSurrounding(module.getName().asString(), "<", ">");
     }

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.serialization.ProtoBuf
@@ -92,7 +92,7 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
                 { ModuleContent(files, GlobalSearchScope.EMPTY_SCOPE) },
                 JvmPlatformParameters { throw IllegalStateException() },
                 CompilerEnvironment,
-                packageMappingProviderFactory = { a, b -> JvmPackageMappingProvider(environment) }
+                packageFacadeProviderFactory = { a, b -> JvmPackageFacadeProvider(environment) }
         )
 
         val moduleDescriptor = resolver.descriptorForModule(builtInModule)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/JvmPackageFacadeProvider.kt

@@ -14,27 +14,35 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.resolve.lazy
+package org.jetbrains.kotlin.cli.jvm.compiler
 
 import com.intellij.openapi.vfs.VirtualFile
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 
-public class JvmPackageMappingProvider(val env: KotlinCoreEnvironment) : PackageMappingProvider {
+public class JvmPackageFacadeProvider(val env: KotlinCoreEnvironment) : PackageFacadeProvider {
-    override fun findPackageMembers(packageName: String): List<String> {
+
-        val res = env.configuration.getList(CommonConfigurationKeys.CONTENT_ROOTS).
+    val roots by lazy {
+        env.configuration.getList(CommonConfigurationKeys.CONTENT_ROOTS).
                 filterIsInstance<JvmClasspathRoot>().
                 map {
                     env.contentRootToVirtualFile(it);
-                }.filterNotNull()
+                }.filter { it?.findChild("META-INF") != null }.filterNotNull()
+    }
 
-        //TODO additional filtering by package existing
+    override fun findPackageFacades(packageInternalName: String): List<String> {
-        //val path = packageName.split("/")
+        val pathParts = packageInternalName.split('/')
-
+        val mappings = roots.filter {
-        val mappings = res.map {
+            //filter all roots by package path existing
+            pathParts.fold(it) {
+                parent, part ->
+                if (part.isEmpty()) parent
+                else  parent.findChild(part) ?: return@filter false
+            }
+            true
+        }.map {
             it.findChild("META-INF")
         }.filterNotNull().flatMap {
             it.children.filter { it.name.endsWith(ModuleMapping.MAPPING_FILE_EXT) }.toList<VirtualFile>()
@@ -42,6 +50,6 @@ public class JvmPackageMappingProvider(val env: KotlinCoreEnvironment) : Package
             ModuleMapping(String(it.contentsToByteArray(), "UTF-8"))
         }
 
-        return mappings.map { it.findPackageParts(packageName) }.filterNotNull().flatMap { it.parts }.distinct()
+        return mappings.map { it.findPackageParts(packageInternalName) }.filterNotNull().flatMap { it.parts }.distinct()
     }
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java

@@ -57,7 +57,6 @@ import org.jetbrains.kotlin.resolve.BindingTraceContext;
 import org.jetbrains.kotlin.resolve.ScriptNameUtil;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
 import org.jetbrains.kotlin.util.PerformanceCounter;
 import org.jetbrains.kotlin.utils.KotlinPaths;
 
@@ -328,7 +327,7 @@ public class KotlinToJVMBytecodeCompiler {
                                 sharedTrace,
                                 environment.getConfiguration().get(JVMConfigurationKeys.MODULE_IDS),
                                 environment.getConfiguration().get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS),
-                                new JvmPackageMappingProvider(environment)
+                                new JvmPackageFacadeProvider(environment)
                         );
                     }
                 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java

@@ -57,7 +57,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider;
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.kotlin.resolve.lazy.declarations.*;
@@ -127,7 +127,7 @@ public class ReplInterpreter {
                 scriptDeclarationFactory,
                 ProjectScope.getAllScope(project),
                 scopeProvider,
-                new JvmPackageMappingProvider(environment)
+                new JvmPackageFacadeProvider(environment)
         );
 
         this.topDownAnalysisContext = new TopDownAnalysisContext(TopDownAnalysisMode.LocalDeclarations, DataFlowInfo.EMPTY,

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.frontend.java.di.configureJavaTopDownAnalysis
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.BodyResolveCache
@@ -40,9 +40,9 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 public fun createContainerForReplWithJava(
         moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: FileScopeProvider.AdditionalScopes,
-        packageMappingProvider: PackageMappingProvider
+        packageFacadeProvider: PackageFacadeProvider
 ): ContainerForReplWithJava = createContainer("ReplWithJava") {
-    useInstance(packageMappingProvider)
+    useInstance(packageFacadeProvider)
     configureModule(moduleContext, JvmPlatform, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING)
 

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
 import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider
 import org.jetbrains.kotlin.load.java.components.*
 import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
 import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl
 import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl
@@ -72,10 +72,10 @@ public fun createContainerForLazyResolveWithJava(
         moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope, moduleClassResolver: ModuleClassResolver,
         targetEnvironment: TargetEnvironment = CompilerEnvironment,
-        packageMappingProvider: PackageMappingProvider
+        packageFacadeProvider: PackageFacadeProvider
 ): ComponentProvider = createContainer("LazyResolveWithJava") {
     //TODO: idea specific code
-    useInstance(packageMappingProvider)
+    useInstance(packageFacadeProvider)
 
     configureModule(moduleContext, JvmPlatform, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING)
@@ -99,9 +99,9 @@ public fun createContainerForTopDownAnalyzerForJvm(
         declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope,
         lookupTracker: LookupTracker,
-        packageMappingProvider: PackageMappingProvider
+        packageFacadeProvider: PackageFacadeProvider
 ): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm") {
-    useInstance(packageMappingProvider)
+    useInstance(packageFacadeProvider)
 
     configureModule(moduleContext, JvmPlatform, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker)

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

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
 import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava
 import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
@@ -51,7 +51,7 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
             platformParameters: JvmPlatformParameters,
             targetEnvironment: TargetEnvironment,
             resolverForProject: ResolverForProject<M>,
-            packageMappingProvider: PackageMappingProvider
+            packageFacadeProvider: PackageFacadeProvider
     ): ResolverForModule {
         val (syntheticFiles, moduleContentScope) = moduleContent
         val project = moduleContext.project
@@ -72,7 +72,7 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
                 moduleContentScope,
                 moduleClassResolver,
                 targetEnvironment,
-                packageMappingProvider
+                packageFacadeProvider
         )
         val resolveSession = container.get<ResolveSession>()
         val javaDescriptorResolver = container.get<JavaDescriptorResolver>()

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java

@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension;
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider;
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider;
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -93,9 +93,9 @@ public enum TopDownAnalyzerFacadeForJVM {
             @NotNull Collection<JetFile> files,
             @NotNull BindingTrace trace,
             @NotNull TopDownAnalysisMode topDownAnalysisMode,
-            PackageMappingProvider packageMappingProvider
+            PackageFacadeProvider packageFacadeProvider
     ) {
-        return analyzeFilesWithJavaIntegration(moduleContext, files, trace, topDownAnalysisMode, null, null, packageMappingProvider);
+        return analyzeFilesWithJavaIntegration(moduleContext, files, trace, topDownAnalysisMode, null, null, packageFacadeProvider);
     }
 
     @NotNull
@@ -105,11 +105,11 @@ public enum TopDownAnalyzerFacadeForJVM {
             @NotNull BindingTrace trace,
             @Nullable List<String> moduleIds,
             @Nullable IncrementalCompilationComponents incrementalCompilationComponents,
-            @NotNull PackageMappingProvider packageMappingProvider
+            @NotNull PackageFacadeProvider packageFacadeProvider
     ) {
         return analyzeFilesWithJavaIntegration(
                 moduleContext, files, trace, TopDownAnalysisMode.TopLevelDeclarations, moduleIds, incrementalCompilationComponents,
-                packageMappingProvider);
+                packageFacadeProvider);
     }
 
     @NotNull
@@ -120,7 +120,7 @@ public enum TopDownAnalyzerFacadeForJVM {
             @NotNull TopDownAnalysisMode topDownAnalysisMode,
             @Nullable List<String> moduleIds,
             @Nullable IncrementalCompilationComponents incrementalCompilationComponents,
-            @NotNull PackageMappingProvider packageMappingProvider
+            @NotNull PackageFacadeProvider packageFacadeProvider
     ) {
         Project project = moduleContext.getProject();
         List<JetFile> allFiles = JvmAnalyzerFacade.getAllFilesToAnalyze(project, null, files);
@@ -137,7 +137,7 @@ public enum TopDownAnalyzerFacadeForJVM {
                 providerFactory,
                 GlobalSearchScope.allScope(project),
                 lookupTracker,
-                packageMappingProvider
+                packageFacadeProvider
         );
 
         List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.LazyModuleDependencies
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.JetFile
@@ -130,7 +130,7 @@ public abstract class AnalyzerFacade<in P : PlatformAnalysisParameters> {
             platformParameters: P,
             targetEnvironment: TargetEnvironment,
             delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
-            packageMappingProviderFactory: (M, ModuleContent) -> PackageMappingProvider = { (m, c) -> PackageMappingProvider.EMPTY }
+            packageFacadeProviderFactory: (M, ModuleContent) -> PackageFacadeProvider = { (m, c) -> PackageFacadeProvider.EMPTY }
     ): ResolverForProject<M> {
         val storageManager = projectContext.storageManager
         fun createResolverForProject(): ResolverForProjectImpl<M> {
@@ -187,7 +187,7 @@ public abstract class AnalyzerFacade<in P : PlatformAnalysisParameters> {
                     createResolverForModule(
                             module, descriptor, projectContext.withModule(descriptor), modulesContent(module),
                             platformParameters, targetEnvironment, resolverForProject,
-                            packageMappingProviderFactory(module, content)
+                            packageFacadeProviderFactory(module, content)
                     )
                 }
 
@@ -208,7 +208,7 @@ public abstract class AnalyzerFacade<in P : PlatformAnalysisParameters> {
             platformParameters: P,
             targetEnvironment: TargetEnvironment,
             resolverForProject: ResolverForProject<M>,
-            packageMappingProvider: PackageMappingProvider
+            packageFacadeProvider: PackageFacadeProvider
     ): ResolverForModule
 
     public abstract val moduleParameters: ModuleParameters

compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java

@@ -48,7 +48,7 @@ import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.storage.ExceptionTracker;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
@@ -248,7 +248,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
                 moduleTrace,
                 null,
                 null,
-                new JvmPackageMappingProvider(getEnvironment())
+                new JvmPackageFacadeProvider(getEnvironment())
         );
     }
 

compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
 import org.jetbrains.kotlin.resolve.BindingTraceContext;
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.test.JetTestUtils;
 import org.jetbrains.kotlin.utils.UtilsPackage;
@@ -53,7 +53,7 @@ public class CodegenTestUtil {
         AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
                 environment.getProject(),
                 files.getPsiFiles(),
-                new JvmPackageMappingProvider(environment)
+                new JvmPackageFacadeProvider(environment)
         );
         analysisResult.throwIfError();
         AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext());

compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java

@@ -19,11 +19,11 @@ package org.jetbrains.kotlin.codegen;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider;
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider;
 import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 
 import java.util.Collections;
@@ -48,20 +48,21 @@ public class GenerationUtils {
             @NotNull KotlinCoreEnvironment environment
     ) {
         AnalysisResult analysisResult =
-                JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile, new JvmPackageMappingProvider(environment));
+                JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile, new JvmPackageFacadeProvider(environment));
         return compileFilesGetGenerationState(psiFile.getProject(), analysisResult, Collections.singletonList(psiFile));
     }
 
     @NotNull
     public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List<JetFile> files) {
-        return compileManyFilesGetGenerationStateForTest(project, files, PackageMappingProvider.EMPTY);
+        return compileManyFilesGetGenerationStateForTest(project, files, PackageFacadeProvider.EMPTY);
     }
 
     @NotNull
     public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List<JetFile> files,
-            @NotNull PackageMappingProvider packageMappingProvider) {
+            @NotNull PackageFacadeProvider packageFacadeProvider
+    ) {
         AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
-                project, files, packageMappingProvider);
+                project, files, packageFacadeProvider);
         return compileFilesGetGenerationState(project, analysisResult, files);
     }
 

compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.codegen.CodegenTestCase;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.psi.JetFile;
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.jetbrains.kotlin.test.JetTestUtils;
@@ -155,7 +155,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
         loadFiles(ArrayUtil.toStringArray(ktFilePaths));
         classFileFactory =
                 GenerationUtils.compileManyFilesGetGenerationStateForTest(myEnvironment.getProject(), myFiles.getPsiFiles(),
-                                                                          new JvmPackageMappingProvider(myEnvironment)).getFactory();
+                                                                          new JvmPackageFacadeProvider(myEnvironment)).getFactory();
         File kotlinOut = JetTestUtils.tmpDir(toString());
         OutputUtilsPackage.writeAllTo(classFileFactory, kotlinOut);
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java

@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.TopDownAnalysisMode;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.kotlin.test.ConfigurationKind;
@@ -156,7 +156,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
                 environment.getSourceFiles(),
                 trace,
                 TopDownAnalysisMode.TopLevelDeclarations,
-                new JvmPackageMappingProvider(environment)
+                new JvmPackageFacadeProvider(environment)
         );
 
         PackageViewDescriptor packageView = moduleContext.getModule().getPackage(TEST_PACKAGE_FQNAME);

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractSdkAnnotationsValidityTest.java

@@ -35,7 +35,6 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.kotlinSignature.TypeTransformingVisitor;
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt

@@ -23,7 +23,7 @@ import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.cli.common.output.outputUtils.writeAllTo
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.GenerationUtils
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir
 import org.jetbrains.kotlin.utils.join

compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java

@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.test.ConfigurationKind;
@@ -141,7 +141,7 @@ public final class LoadDescriptorUtil {
                 }
             });
             AnalysisResult result = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
-                    jetCoreEnvironment.getProject(), jetFiles, new JvmPackageMappingProvider(jetCoreEnvironment));
+                    jetCoreEnvironment.getProject(), jetFiles, new JvmPackageFacadeProvider(jetCoreEnvironment));
             return new JetFilesAndAnalysisResult(jetFiles, result);
         }
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt

@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.junit.Assert
@@ -67,7 +67,7 @@ public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() {
                     modules.first { it._name == moduleName }
                 },
                 CompilerEnvironment,
-                packageMappingProviderFactory = { a, b -> JvmPackageMappingProvider(environment)}
+                packageFacadeProviderFactory = { a, b -> JvmPackageFacadeProvider(environment) }
         )
 
         performChecks(resolverForProject, modules)

compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java

@@ -20,9 +20,10 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.context.ModuleContext;
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider;
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
 import org.jetbrains.kotlin.resolve.BindingTrace;
@@ -36,11 +37,11 @@ public class JvmResolveUtil {
     public static String TEST_MODULE_NAME = "java-integration-test";
     @NotNull
     public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file) {
-        return analyzeOneFileWithJavaIntegrationAndCheckForErrors(file, PackageMappingProvider.EMPTY);
+        return analyzeOneFileWithJavaIntegrationAndCheckForErrors(file, PackageFacadeProvider.EMPTY);
     }
 
     @NotNull
-    public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file, @NotNull PackageMappingProvider provider) {
+    public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file, @NotNull PackageFacadeProvider provider) {
         AnalyzingUtils.checkForSyntacticErrors(file);
 
         AnalysisResult analysisResult = analyzeOneFileWithJavaIntegration(file, provider);
@@ -52,17 +53,17 @@ public class JvmResolveUtil {
 
     @NotNull
     public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull KotlinCoreEnvironment environment) {
-        return analyzeOneFileWithJavaIntegration(file, new JvmPackageMappingProvider(environment));
+        return analyzeOneFileWithJavaIntegration(file, new JvmPackageFacadeProvider(environment));
     }
 
     @NotNull
-    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull PackageMappingProvider provider) {
+    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull PackageFacadeProvider provider) {
         return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), provider);
     }
 
     @NotNull
     public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file) {
-        return analyzeOneFileWithJavaIntegration(file, PackageMappingProvider.EMPTY);
+        return analyzeOneFileWithJavaIntegration(file, PackageFacadeProvider.EMPTY);
     }
 
     @NotNull
@@ -70,20 +71,20 @@ public class JvmResolveUtil {
             @NotNull Project project,
             @NotNull Collection<JetFile> files
     ) {
-        return analyzeFilesWithJavaIntegrationAndCheckForErrors(project, files, PackageMappingProvider.EMPTY);
+        return analyzeFilesWithJavaIntegrationAndCheckForErrors(project, files, PackageFacadeProvider.EMPTY);
     }
 
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegrationAndCheckForErrors(
             @NotNull Project project,
             @NotNull Collection<JetFile> files,
-            @NotNull PackageMappingProvider packageMappingProvider
+            @NotNull PackageFacadeProvider packageFacadeProvider
     ) {
         for (JetFile file : files) {
             AnalyzingUtils.checkForSyntacticErrors(file);
         }
 
-        AnalysisResult analysisResult = analyzeFilesWithJavaIntegration(project, files, packageMappingProvider);
+        AnalysisResult analysisResult = analyzeFilesWithJavaIntegration(project, files, packageFacadeProvider);
 
         AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext());
 
@@ -96,20 +97,21 @@ public class JvmResolveUtil {
             @NotNull Collection<JetFile> files,
             @NotNull KotlinCoreEnvironment environment
     ) {
-        return analyzeFilesWithJavaIntegration(project, files, new JvmPackageMappingProvider(environment));
+        return analyzeFilesWithJavaIntegration(project, files, new JvmPackageFacadeProvider(environment));
     }
 
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegration(
             @NotNull Project project,
             @NotNull Collection<JetFile> files,
-            @NotNull PackageMappingProvider packageMappingProvider
+            @NotNull PackageFacadeProvider packageFacadeProvider
     ) {
 
         ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, TEST_MODULE_NAME);
 
         BindingTrace trace = new CliLightClassGenerationSupport.CliBindingTrace();
 
-        return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(moduleContext, files, trace, null, null, packageMappingProvider);
+        return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(moduleContext, files, trace, null, null,
+                                                                                            packageFacadeProvider);
     }
 }

compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java

@@ -20,10 +20,10 @@ import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackageFacadeProvider;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.psi.JetFile;
@@ -62,7 +62,7 @@ public class LazyResolveTestUtil {
 
         TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
                 moduleContext, sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations,
-                new JvmPackageMappingProvider(environment)
+                new JvmPackageFacadeProvider(environment)
         );
 
         return moduleContext.getModule();

compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerFo
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.load.java.structure.reflect.classId
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
@@ -60,7 +60,7 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
 
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                providerFactory, GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackageMappingProvider.EMPTY
+                providerFactory, GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackageFacadeProvider.EMPTY
         )
         moduleContext.initializeModuleContents(container.javaDescriptorResolver.packageFragmentProvider)
 

compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java

@@ -66,7 +66,6 @@ import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
-import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaPackageFragmentProvider.kt

@@ -30,8 +30,7 @@ import org.jetbrains.kotlin.utils.emptyOrSingletonList
 public class LazyJavaPackageFragmentProvider(
         components: JavaResolverComponents,
         module: ModuleDescriptor,
-        reflectionTypes: ReflectionTypes,
+        reflectionTypes: ReflectionTypes
-        packageMapper: PackageMappingProvider
 ) : PackageFragmentProvider {
 
     private val c =
@@ -42,7 +41,7 @@ public class LazyJavaPackageFragmentProvider(
                 fqName ->
                 val jPackage = c.components.finder.findPackage(fqName)
                 if (jPackage != null) {
-                    LazyJavaPackageFragment(c, jPackage, packageMapper)
+                    LazyJavaPackageFragment(c, jPackage)
                 }
                 else null
             }

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/context.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.load.java.lazy
 import org.jetbrains.kotlin.builtins.ReflectionTypes
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.components.ExternalAnnotationResolver
 import org.jetbrains.kotlin.load.java.components.ExternalSignatureResolver
@@ -45,7 +46,8 @@ class JavaResolverComponents(
         val javaPropertyInitializerEvaluator: JavaPropertyInitializerEvaluator,
         val samConversionResolver: SamConversionResolver,
         val sourceElementFactory: JavaSourceElementFactory,
-        val moduleClassResolver: ModuleClassResolver
+        val moduleClassResolver: ModuleClassResolver,
+        val packageMapper: PackageFacadeProvider
 )
 
 open class LazyJavaResolverContext(

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageFragment.kt

@@ -19,9 +19,7 @@ package org.jetbrains.kotlin.load.java.lazy.descriptors
 import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
-
 import org.jetbrains.kotlin.load.java.structure.JavaClass
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
 import org.jetbrains.kotlin.load.java.structure.JavaPackage
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinarySourceElement
 import org.jetbrains.kotlin.resolve.scopes.DecapitalizedAnnotationScope
@@ -29,8 +27,7 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope
 
 class LazyJavaPackageFragment(
         private val c: LazyJavaResolverContext,
-        private val jPackage: JavaPackage,
+        private val jPackage: JavaPackage
-        val packageMapper: PackageMappingProvider
 ) : PackageFragmentDescriptorImpl(c.module, jPackage.getFqName()) {
     val scope: LazyJavaPackageScope by lazy { LazyJavaPackageScope(c, jPackage, this) }
     // Just a temporary hack to inject deprecated decapitalized annotation

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt

@@ -50,41 +50,19 @@ public class LazyJavaPackageScope(
 
     public val kotlinBinaryClasses: List<KotlinJvmBinaryClass>
     init {
-        val pakage = jPackage.getFqName().asString().replace('.', '/')
+        val files = c.components.packageMapper.findPackageFacades(jPackage.getFqName().asString().replace('.', '/'))
-        val files = containingDeclaration.packageMapper.findPackageMembers(pakage)
         val packageClassId = PackageClassUtils.getPackageClassId(packageFragment.fqName).packageFqName
-        val notFound = arrayListOf<String>()
+        kotlinBinaryClasses = files.map {
-        val classFiles = files.map {
             val classId = ClassId(packageClassId, Name.identifierNoValidate(it.substringAfterLast("/")))
-            val findKotlinClass = c.components.kotlinClassFinder.findKotlinClass(classId)
+            c.components.kotlinClassFinder.findKotlinClass(classId)
-            if (findKotlinClass == null) {
+        }.filterNotNull()
-                notFound.add("$classId")
-            }
-            findKotlinClass
-        }
-        kotlinBinaryClasses = classFiles.filterNotNull()
-        if (kotlinBinaryClasses.size() != classFiles.size()) {
-            println("package: $pakage")
-            println("files: " + files.join())
-            println("not found: " + notFound.join())
-            //assert(kotlinBinaryClasses.size() == classFiles.size(), "${kotlinBinaryClasses.size()} != ${classFiles.size()}")
-        }
     }
 
     private val deserializedPackageScope = c.storageManager.createLazyValue {
-        val kotlinBinaryClass = kotlinBinaryClass
         if (kotlinBinaryClasses.isEmpty())
             JetScope.Empty
         else {
-
+            c.components.deserializedDescriptorResolver.createKotlinNewPackageScope(packageFragment, kotlinBinaryClasses)
-            //if(!kotlinBinaryClasses.isEmpty()) {
-                c.components.deserializedDescriptorResolver.createKotlinNewPackageScope(packageFragment, kotlinBinaryClasses)
-                //print("deserializing " + packageFragment.getName())
-            //}
-
-//            val jetScope = c.deserializedDescriptorResolver.createKotlinPackageScope(packageFragment, kotlinBinaryClass) ?: JetScope.Empty
-//            jetScope
-
         }
     }
 

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/ModuleMapping.kt

@@ -40,13 +40,13 @@ public class ModuleMapping(val moduleMapping: String) {
     }
 }
 
-public class PackageFacades(val internalName: String) {
+public class PackageFacades(val packageInternalName: String) {
 
     val parts = linkedSetOf<String>()
 
     fun serialize(out: Writer) {
         for (i in parts) {
-            out.write("$internalName->$i\n")
+            out.write("$packageInternalName->$i\n")
         }
     }
 
@@ -55,7 +55,7 @@ public class PackageFacades(val internalName: String) {
             return false;
         }
 
-        if (other.internalName != internalName) {
+        if (other.packageInternalName != packageInternalName) {
             return false;
         }
 
@@ -73,6 +73,6 @@ public class PackageFacades(val internalName: String) {
     }
 
     override fun hashCode(): Int {
-        return internalName.hashCode() / 3 + parts.size() / 3+ (parts.firstOrNull()?.hashCode() ?: 0) /3
+        return packageInternalName.hashCode() / 3 + parts.size() / 3 + (parts.firstOrNull()?.hashCode() ?: 0) / 3
     }
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.load.java.components.*
 import org.jetbrains.kotlin.load.java.lazy.JavaResolverComponents
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
 import org.jetbrains.kotlin.load.java.reflect.ReflectJavaClassFinder
 import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator
@@ -55,12 +55,11 @@ public class RuntimeModuleData private constructor(public val deserialization: D
             val globalJavaResolverContext = JavaResolverComponents(
                     storageManager, ReflectJavaClassFinder(classLoader), reflectKotlinClassFinder, deserializedDescriptorResolver,
                     ExternalAnnotationResolver.EMPTY, ExternalSignatureResolver.DO_NOTHING, RuntimeErrorReporter, JavaResolverCache.EMPTY,
-                    JavaPropertyInitializerEvaluator.DoNothing, SamConversionResolver, RuntimeSourceElementFactory, singleModuleClassResolver
+                    JavaPropertyInitializerEvaluator.DoNothing, SamConversionResolver, RuntimeSourceElementFactory, singleModuleClassResolver,
+                    if (moduleName == null) PackageFacadeProvider.EMPTY else RuntimePackageFacadeProvider(moduleName, classLoader)
             )
-                println("moduleName $moduleName")
             val lazyJavaPackageFragmentProvider =
-                    LazyJavaPackageFragmentProvider(globalJavaResolverContext, module, ReflectionTypes(module),
+                    LazyJavaPackageFragmentProvider(globalJavaResolverContext, module, ReflectionTypes(module))
-                                                    if (moduleName == null) PackageMappingProvider.EMPTY else RuntimePackageMappingProvider(moduleName, classLoader))
             val javaDescriptorResolver = JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module)
             val javaClassDataFinder = JavaClassDataFinder(reflectKotlinClassFinder, deserializedDescriptorResolver)
             val binaryClassAnnotationAndConstantLoader = BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, reflectKotlinClassFinder, RuntimeErrorReporter)

core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimePackageFacadeProvider.kt

@@ -16,37 +16,33 @@
 
 package org.jetbrains.kotlin.load.kotlin.reflect
 
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import org.jetbrains.kotlin.load.kotlin.PackageFacades
 import java.io.ByteArrayOutputStream
 
-class RuntimePackageMappingProvider(val moduleName: String, val classLoader : ClassLoader) : PackageMappingProvider {
+class RuntimePackageFacadeProvider(val moduleName: String, val classLoader : ClassLoader) : PackageFacadeProvider {
 
     val mapping: ModuleMapping by lazy {
-        print("finding metainf for $moduleName")
         val resourceAsStream = classLoader.getResourceAsStream("META-INF/$moduleName.kotlin_module") ?: return@lazy ModuleMapping("")
 
-        print("OK")
-
         try {
-            val out = ByteArrayOutputStream(4096);
+            val out = ByteArrayOutputStream(4096)
-            val buffer = ByteArray(4096);
+            val buffer = ByteArray(4096)
             while (true) {
-                val r = resourceAsStream.read(buffer);
+                val r = resourceAsStream.read(buffer)
-                if (r == -1) break;
+                if (r == -1) break
-                out.write(buffer, 0, r);
+                out.write(buffer, 0, r)
             }
 
-            val ret = out.toByteArray();
+            val ret = out.toByteArray()
             return@lazy ModuleMapping(String(ret, "UTF-8"))
         } finally {
             resourceAsStream.close()
         }
     }
 
-    override fun findPackageMembers(packageName: String): List<String> {
+    override fun findPackageFacades(packageInternalName: String): List<String> {
-        print("finding $packageName")
+        return mapping.package2MiniFacades.getOrElse (packageInternalName, { PackageFacades("default") }).parts.toList()
-        return mapping.package2MiniFacades.getOrElse (packageName, { PackageFacades("default") }).parts.toList()
     }
 }

core/descriptors/src/org/jetbrains/kotlin/descriptors/PackageFacadeProvider.kt

@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.load.java.lazy
+package org.jetbrains.kotlin.descriptors
 
-interface PackageMappingProvider {
+interface PackageFacadeProvider {
 
-    fun findPackageMembers(packageName: String): List<String>
+    fun findPackageFacades(packageInternalName: String): List<String>
 
     companion object {
-        val EMPTY = object : PackageMappingProvider {
+        val EMPTY = object : PackageFacadeProvider {
-            override fun findPackageMembers(packageName: String): List<String> {
+            override fun findPackageFacades(packageInternalName: String): List<String> {
                 return emptyList()
             }
         }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDEPackageFacadeProvider.kt

@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.idea.caches.resolve
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.util.indexing.FileBasedIndex
 import org.jetbrains.kotlin.idea.vfilefinder.KotlinModuleMappingIndex
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.load.kotlin.PackageFacades
 
-public class IDEPackageMappingProvider(val scope: GlobalSearchScope) : PackageMappingProvider {
+public class IDEPackageFacadeProvider(val scope: GlobalSearchScope) : PackageFacadeProvider {
 
-    override fun findPackageMembers(packageName: String): List<String> {
+    override fun findPackageFacades(packageInternalName: String): List<String> {
-        val values: MutableList<PackageFacades> = FileBasedIndex.getInstance().getValues(KotlinModuleMappingIndex.KEY, packageName, scope)
+        val values: MutableList<PackageFacades> = FileBasedIndex.getInstance().getValues(KotlinModuleMappingIndex.KEY, packageInternalName, scope)
         return values.flatMap { it.parts }.distinct()
     }
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.frontend.di.createContainerForLazyResolve
 import org.jetbrains.kotlin.idea.framework.KotlinJavaScriptLibraryDetectionUtil
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.resolve.JsPlatform
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.TargetEnvironment
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
@@ -47,7 +47,7 @@ public object JsAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
             platformParameters: PlatformAnalysisParameters,
             targetEnvironment: TargetEnvironment,
             resolverForProject: ResolverForProject<M>,
-            packageMappingProvider: PackageMappingProvider
+            packageFacadeProvider: PackageFacadeProvider
     ): ResolverForModule {
         val (syntheticFiles, moduleContentScope) = moduleContent
         val project = moduleContext.project

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt

@@ -64,7 +64,7 @@ fun createModuleResolverProvider(
         val resolverForProject = analyzerFacade.setupResolverForProject(
                 globalContext.withProject(project), modulesToCreateResolversFor, modulesContent,
                 jvmPlatformParameters, IdeaEnvironment, delegateResolver,
-                { (m, c) -> IDEPackageMappingProvider(c.moduleContentScope) }
+                { (m, c) -> IDEPackageFacadeProvider(c.moduleContentScope) }
         )
         return resolverForProject
     }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/vfilefinder/moduleMappingIndexes.kt

@@ -66,7 +66,7 @@ public object KotlinModuleMappingIndex : FileBasedIndexExtension<String, Package
         }
 
         override fun save(out: DataOutput, value: PackageFacades?) {
-            out.writeUTF(value!!.internalName)
+            out.writeUTF(value!!.packageInternalName)
             out.writeInt(value.parts.size())
             value.parts.forEach { out.writeUTF(it) }
         }

idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
-import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider
+import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
 
 public class DecompiledTextConsistencyTest : TextConsistencyBaseTest() {
 
@@ -42,7 +42,7 @@ public class DecompiledTextConsistencyTest : TextConsistencyBaseTest() {
     override fun getModuleDescriptor(): ModuleDescriptor =
             TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
                     TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(getProject(), "test"),
-                    listOf(), BindingTraceContext(), null, null, PackageMappingProvider.EMPTY
+                    listOf(), BindingTraceContext(), null, null, PackageFacadeProvider.EMPTY
             ).moduleDescriptor
 
     override fun getProjectDescriptor() = object : JetWithJdkAndRuntimeLightProjectDescriptor() {