PackagePartProvider refactoring

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

@@ -89,7 +89,7 @@ public class ClassFileFactory implements OutputFileCollection {
         String outputFilePath = getMappingFileName(state.getModuleName());
         final StringWriter moduleMapping = new StringWriter(1024);
         for (PackageCodegen codegen : values) {
-            codegen.getFacades().serialize(moduleMapping);
+            codegen.getPackageParts().serialize(moduleMapping);
         }
         state.getProgress().reportOutput(Collections.<File>emptyList(), new File(outputFilePath));
         //TODO: source files?

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

@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.codegen.context.MethodContext;
 import org.jetbrains.kotlin.codegen.context.PackageContext;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.config.IncrementalCompilation;
-import org.jetbrains.kotlin.load.kotlin.PackageFacades;
+import org.jetbrains.kotlin.load.kotlin.PackageParts;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
@@ -84,7 +84,7 @@ public class PackageCodegen {
     private final PackageFragmentDescriptor compiledPackageFragment;
     private final List<DeserializedCallableMemberDescriptor> previouslyCompiledCallables;
 
-    private final PackageFacades facades;
+    private final PackageParts packageParts;
 
     public PackageCodegen(@NotNull GenerationState state, @NotNull Collection<JetFile> files, @NotNull FqName fqName) {
         this.state = state;
@@ -120,7 +120,7 @@ public class PackageCodegen {
                 return v;
             }
         });
-        facades = new PackageFacades(fqName.asString().replaceAll("\\.", "/"));
+        packageParts = new PackageParts(fqName.asString().replaceAll("\\.", "/"));
     }
 
     // Returns null if file has callables in several files
@@ -338,7 +338,7 @@ public class PackageCodegen {
 
         if (!generatePackagePart || !state.getGenerateDeclaredClassFilter().shouldGeneratePackagePart(file)) return null;
 
-        facades.getParts().add(packagePartType.getInternalName());
+        packageParts.getParts().add(packagePartType.getInternalName());
 
         ClassBuilder builder = state.getFactory().newVisitor(PackagePart(file, packageFragment), packagePartType, file);
 
@@ -422,7 +422,7 @@ public class PackageCodegen {
         v.done();
     }
 
-    public PackageFacades getFacades() {
+    public PackageParts getPackageParts() {
-        return facades;
+        return packageParts;
     }
 }

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.cli.jvm.compiler.JvmPackageFacadeProvider
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
 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,
-                packageFacadeProviderFactory = { a, b -> JvmPackageFacadeProvider(environment) }
+                packagePartProviderFactory = { a, b -> JvmPackagePartProvider(environment) }
         )
 
         val moduleDescriptor = resolver.descriptorForModule(builtInModule)

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

@@ -19,10 +19,10 @@ package org.jetbrains.kotlin.cli.jvm.compiler
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
+import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 
-public class JvmPackageFacadeProvider(val env: KotlinCoreEnvironment) : PackageFacadeProvider {
+public class JvmPackagePartProvider(val env: KotlinCoreEnvironment) : PackagePartProvider {
 
     val roots by lazy {
         env.configuration.getList(CommonConfigurationKeys.CONTENT_ROOTS).
@@ -32,7 +32,7 @@ public class JvmPackageFacadeProvider(val env: KotlinCoreEnvironment) : PackageF
                 }.filter { it?.findChild("META-INF") != null }.filterNotNull()
     }
 
-    override fun findPackageFacades(packageInternalName: String): List<String> {
+    override fun findPackageParts(packageInternalName: String): List<String> {
         val pathParts = packageInternalName.split('/')
         val mappings = roots.filter {
             //filter all roots by package path existing

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

@@ -328,7 +328,7 @@ public class KotlinToJVMBytecodeCompiler {
                                 sharedTrace,
                                 environment.getConfiguration().get(JVMConfigurationKeys.MODULE_IDS),
                                 environment.getConfiguration().get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS),
-                                new JvmPackageFacadeProvider(environment)
+                                new JvmPackagePartProvider(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.cli.jvm.compiler.JvmPackageFacadeProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
 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 JvmPackageFacadeProvider(environment)
+                new JvmPackagePartProvider(environment)
         );
 
         this.topDownAnalysisContext = new TopDownAnalysisContext(TopDownAnalysisMode.LocalDeclarations, DataFlowInfo.EMPTY,

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

@@ -19,14 +19,13 @@ package org.jetbrains.kotlin.cli.jvm.repl.di
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.descriptors.PackagePartProvider
 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.descriptors.PackageFacadeProvider
 import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.BodyResolveCache
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
 import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
@@ -40,9 +39,9 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 public fun createContainerForReplWithJava(
         moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: FileScopeProvider.AdditionalScopes,
-        packageFacadeProvider: PackageFacadeProvider
+        packagePartProvider: PackagePartProvider
 ): ContainerForReplWithJava = createContainer("ReplWithJava") {
-    useInstance(packageFacadeProvider)
+    useInstance(packagePartProvider)
     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.descriptors.PackageFacadeProvider
+import org.jetbrains.kotlin.descriptors.PackagePartProvider
 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,
-        packageFacadeProvider: PackageFacadeProvider
+        packagePartProvider: PackagePartProvider
 ): ComponentProvider = createContainer("LazyResolveWithJava") {
     //TODO: idea specific code
-    useInstance(packageFacadeProvider)
+    useInstance(packagePartProvider)
 
     configureModule(moduleContext, JvmPlatform, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING)
@@ -99,9 +99,9 @@ public fun createContainerForTopDownAnalyzerForJvm(
         declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope,
         lookupTracker: LookupTracker,
-        packageFacadeProvider: PackageFacadeProvider
+        packagePartProvider: PackagePartProvider
 ): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm") {
-    useInstance(packageFacadeProvider)
+    useInstance(packagePartProvider)
 
     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.descriptors.PackageFacadeProvider
+import org.jetbrains.kotlin.descriptors.PackagePartProvider
 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>,
-            packageFacadeProvider: PackageFacadeProvider
+            packagePartProvider: PackagePartProvider
     ): ResolverForModule {
         val (syntheticFiles, moduleContentScope) = moduleContent
         val project = moduleContext.project
@@ -72,7 +72,7 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
                 moduleContentScope,
                 moduleClassResolver,
                 targetEnvironment,
-                packageFacadeProvider
+                packagePartProvider
         )
         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.descriptors.PackageFacadeProvider;
+import org.jetbrains.kotlin.descriptors.PackagePartProvider;
 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,
-            PackageFacadeProvider packageFacadeProvider
+            PackagePartProvider packagePartProvider
     ) {
-        return analyzeFilesWithJavaIntegration(moduleContext, files, trace, topDownAnalysisMode, null, null, packageFacadeProvider);
+        return analyzeFilesWithJavaIntegration(moduleContext, files, trace, topDownAnalysisMode, null, null, packagePartProvider);
     }
 
     @NotNull
@@ -105,11 +105,11 @@ public enum TopDownAnalyzerFacadeForJVM {
             @NotNull BindingTrace trace,
             @Nullable List<String> moduleIds,
             @Nullable IncrementalCompilationComponents incrementalCompilationComponents,
-            @NotNull PackageFacadeProvider packageFacadeProvider
+            @NotNull PackagePartProvider packagePartProvider
     ) {
         return analyzeFilesWithJavaIntegration(
                 moduleContext, files, trace, TopDownAnalysisMode.TopLevelDeclarations, moduleIds, incrementalCompilationComponents,
-                packageFacadeProvider);
+                packagePartProvider);
     }
 
     @NotNull
@@ -120,7 +120,7 @@ public enum TopDownAnalyzerFacadeForJVM {
             @NotNull TopDownAnalysisMode topDownAnalysisMode,
             @Nullable List<String> moduleIds,
             @Nullable IncrementalCompilationComponents incrementalCompilationComponents,
-            @NotNull PackageFacadeProvider packageFacadeProvider
+            @NotNull PackagePartProvider packagePartProvider
     ) {
         Project project = moduleContext.getProject();
         List<JetFile> allFiles = JvmAnalyzerFacade.getAllFilesToAnalyze(project, null, files);
@@ -137,7 +137,7 @@ public enum TopDownAnalyzerFacadeForJVM {
                 providerFactory,
                 GlobalSearchScope.allScope(project),
                 lookupTracker,
-                packageFacadeProvider
+                packagePartProvider
         );
 
         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.descriptors.PackageFacadeProvider
+import org.jetbrains.kotlin.descriptors.PackagePartProvider
 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(),
-            packageFacadeProviderFactory: (M, ModuleContent) -> PackageFacadeProvider = { (m, c) -> PackageFacadeProvider.EMPTY }
+            packagePartProviderFactory: (M, ModuleContent) -> PackagePartProvider = { (m, c) -> PackagePartProvider.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,
-                            packageFacadeProviderFactory(module, content)
+                            packagePartProviderFactory(module, content)
                     )
                 }
 
@@ -208,7 +208,7 @@ public abstract class AnalyzerFacade<in P : PlatformAnalysisParameters> {
             platformParameters: P,
             targetEnvironment: TargetEnvironment,
             resolverForProject: ResolverForProject<M>,
-            packageFacadeProvider: PackageFacadeProvider
+            packagePartProvider: PackagePartProvider
     ): 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.cli.jvm.compiler.JvmPackageFacadeProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
 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 JvmPackageFacadeProvider(getEnvironment())
+                new JvmPackagePartProvider(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.cli.jvm.compiler.JvmPackageFacadeProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
 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 JvmPackageFacadeProvider(environment)
+                new JvmPackagePartProvider(environment)
         );
         analysisResult.throwIfError();
         AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext());

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

@@ -19,10 +19,10 @@ 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.JvmPackagePartProvider;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.descriptors.PackageFacadeProvider;
+import org.jetbrains.kotlin.descriptors.PackagePartProvider;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 
@@ -48,21 +48,21 @@ public class GenerationUtils {
             @NotNull KotlinCoreEnvironment environment
     ) {
         AnalysisResult analysisResult =
-                JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile, new JvmPackageFacadeProvider(environment));
+                JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile, new JvmPackagePartProvider(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, PackageFacadeProvider.EMPTY);
+        return compileManyFilesGetGenerationStateForTest(project, files, PackagePartProvider.EMPTY);
     }
 
     @NotNull
     public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List<JetFile> files,
-            @NotNull PackageFacadeProvider packageFacadeProvider
+            @NotNull PackagePartProvider packagePartProvider
     ) {
         AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
-                project, files, packageFacadeProvider);
+                project, files, packagePartProvider);
         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.cli.jvm.compiler.JvmPackageFacadeProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
 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 JvmPackageFacadeProvider(myEnvironment)).getFactory();
+                                                                          new JvmPackagePartProvider(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.cli.jvm.compiler.JvmPackageFacadeProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
 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 JvmPackageFacadeProvider(environment)
+                new JvmPackagePartProvider(environment)
         );
 
         PackageViewDescriptor packageView = moduleContext.getModule().getPackage(TEST_PACKAGE_FQNAME);

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.cli.jvm.compiler.JvmPackageFacadeProvider
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
 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.cli.jvm.compiler.JvmPackageFacadeProvider;
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
 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 JvmPackageFacadeProvider(jetCoreEnvironment));
+                    jetCoreEnvironment.getProject(), jetFiles, new JvmPackagePartProvider(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.cli.jvm.compiler.JvmPackageFacadeProvider
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
 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,
-                packageFacadeProviderFactory = { a, b -> JvmPackageFacadeProvider(environment) }
+                packagePartProviderFactory = { a, b -> JvmPackagePartProvider(environment) }
         )
 
         performChecks(resolverForProject, modules)

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

@@ -20,10 +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.JvmPackagePartProvider;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.context.ModuleContext;
-import org.jetbrains.kotlin.descriptors.PackageFacadeProvider;
+import org.jetbrains.kotlin.descriptors.PackagePartProvider;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.AnalyzingUtils;
 import org.jetbrains.kotlin.resolve.BindingTrace;
@@ -37,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, PackageFacadeProvider.EMPTY);
+        return analyzeOneFileWithJavaIntegrationAndCheckForErrors(file, PackagePartProvider.EMPTY);
     }
 
     @NotNull
-    public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file, @NotNull PackageFacadeProvider provider) {
+    public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file, @NotNull PackagePartProvider provider) {
         AnalyzingUtils.checkForSyntacticErrors(file);
 
         AnalysisResult analysisResult = analyzeOneFileWithJavaIntegration(file, provider);
@@ -53,17 +53,17 @@ public class JvmResolveUtil {
 
     @NotNull
     public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull KotlinCoreEnvironment environment) {
-        return analyzeOneFileWithJavaIntegration(file, new JvmPackageFacadeProvider(environment));
+        return analyzeOneFileWithJavaIntegration(file, new JvmPackagePartProvider(environment));
     }
 
     @NotNull
-    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull PackageFacadeProvider provider) {
+    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull PackagePartProvider provider) {
         return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), provider);
     }
 
     @NotNull
     public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file) {
-        return analyzeOneFileWithJavaIntegration(file, PackageFacadeProvider.EMPTY);
+        return analyzeOneFileWithJavaIntegration(file, PackagePartProvider.EMPTY);
     }
 
     @NotNull
@@ -71,20 +71,20 @@ public class JvmResolveUtil {
             @NotNull Project project,
             @NotNull Collection<JetFile> files
     ) {
-        return analyzeFilesWithJavaIntegrationAndCheckForErrors(project, files, PackageFacadeProvider.EMPTY);
+        return analyzeFilesWithJavaIntegrationAndCheckForErrors(project, files, PackagePartProvider.EMPTY);
     }
 
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegrationAndCheckForErrors(
             @NotNull Project project,
             @NotNull Collection<JetFile> files,
-            @NotNull PackageFacadeProvider packageFacadeProvider
+            @NotNull PackagePartProvider packagePartProvider
     ) {
         for (JetFile file : files) {
             AnalyzingUtils.checkForSyntacticErrors(file);
         }
 
-        AnalysisResult analysisResult = analyzeFilesWithJavaIntegration(project, files, packageFacadeProvider);
+        AnalysisResult analysisResult = analyzeFilesWithJavaIntegration(project, files, packagePartProvider);
 
         AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext());
 
@@ -97,14 +97,14 @@ public class JvmResolveUtil {
             @NotNull Collection<JetFile> files,
             @NotNull KotlinCoreEnvironment environment
     ) {
-        return analyzeFilesWithJavaIntegration(project, files, new JvmPackageFacadeProvider(environment));
+        return analyzeFilesWithJavaIntegration(project, files, new JvmPackagePartProvider(environment));
     }
 
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegration(
             @NotNull Project project,
             @NotNull Collection<JetFile> files,
-            @NotNull PackageFacadeProvider packageFacadeProvider
+            @NotNull PackagePartProvider packagePartProvider
     ) {
 
         ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, TEST_MODULE_NAME);
@@ -112,6 +112,6 @@ public class JvmResolveUtil {
         BindingTrace trace = new CliLightClassGenerationSupport.CliBindingTrace();
 
         return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(moduleContext, files, trace, null, null,
-                                                                                            packageFacadeProvider);
+                                                                                            packagePartProvider);
     }
 }

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

@@ -20,7 +20,7 @@ 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.JvmPackagePartProvider;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
@@ -62,7 +62,7 @@ public class LazyResolveTestUtil {
 
         TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
                 moduleContext, sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations,
-                new JvmPackageFacadeProvider(environment)
+                new JvmPackagePartProvider(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.descriptors.PackageFacadeProvider
+import org.jetbrains.kotlin.descriptors.PackagePartProvider
 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, PackageFacadeProvider.EMPTY
+                providerFactory, GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackagePartProvider.EMPTY
         )
         moduleContext.initializeModuleContents(container.javaDescriptorResolver.packageFragmentProvider)
 

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

@@ -19,7 +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.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.components.ExternalAnnotationResolver
 import org.jetbrains.kotlin.load.java.components.ExternalSignatureResolver
@@ -47,7 +47,7 @@ class JavaResolverComponents(
         val samConversionResolver: SamConversionResolver,
         val sourceElementFactory: JavaSourceElementFactory,
         val moduleClassResolver: ModuleClassResolver,
-        val packageMapper: PackageFacadeProvider
+        val packageMapper: PackagePartProvider
 )
 
 open class LazyJavaResolverContext(

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

@@ -49,7 +49,7 @@ public class LazyJavaPackageScope(
             = c.components.kotlinClassFinder.findKotlinClass(PackageClassUtils.getPackageClassId(packageFragment.fqName))
 
     public val kotlinBinaryClasses: List<KotlinJvmBinaryClass> by lazy {
-        val files = c.components.packageMapper.findPackageFacades(jPackage.getFqName().asString().replace('.', '/'))
+        val files = c.components.packageMapper.findPackageParts(jPackage.getFqName().asString().replace('.', '/'))
         val packageClassId = PackageClassUtils.getPackageClassId(packageFragment.fqName).packageFqName
 
         files.map {

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

@@ -20,19 +20,19 @@ import java.io.Writer
 
 public class ModuleMapping(val moduleMapping: String) {
 
-    val package2MiniFacades = hashMapOf<String, PackageFacades>()
+    val package2Parts = hashMapOf<String, PackageParts>()
 
     init {
         for (i in moduleMapping.split("\n")) {
             if(i.isEmpty()) continue
             val (pakage, facade) = i.split("->")
-            val miniFacades = package2MiniFacades.getOrPut(pakage, { PackageFacades(pakage) })
+            val miniFacades = package2Parts.getOrPut(pakage, { PackageParts(pakage) })
             miniFacades.parts.add(facade)
         }
     }
 
-    fun findPackageParts(internalPackageName: String): PackageFacades? {
+    fun findPackageParts(internalPackageName: String): PackageParts? {
-        return package2MiniFacades[internalPackageName]
+        return package2Parts[internalPackageName]
     }
 
     companion object {
@@ -40,7 +40,7 @@ public class ModuleMapping(val moduleMapping: String) {
     }
 }
 
-public class PackageFacades(val packageInternalName: String) {
+public class PackageParts(val packageInternalName: String) {
 
     val parts = linkedSetOf<String>()
 
@@ -51,7 +51,7 @@ public class PackageFacades(val packageInternalName: String) {
     }
 
     override fun equals(other: Any?): Boolean {
-        if (other !is PackageFacades) {
+        if (other !is PackageParts) {
             return false;
         }
 

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

@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.serialization.deserialization.DeserializationCompone
 import org.jetbrains.kotlin.serialization.deserialization.LocalClassResolver
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 
-public class RuntimeModuleData private constructor(public val deserialization: DeserializationComponents, val packageFacadeProvider: RuntimePackageFacadeProvider) {
+public class RuntimeModuleData private constructor(public val deserialization: DeserializationComponents, val packageFacadeProvider: RuntimePackagePartProvider) {
     public val module: ModuleDescriptor get() = deserialization.moduleDescriptor
     public val localClassResolver: LocalClassResolver get() = deserialization.localClassResolver
 
@@ -51,7 +51,7 @@ public class RuntimeModuleData private constructor(public val deserialization: D
             val reflectKotlinClassFinder = ReflectKotlinClassFinder(classLoader)
             val deserializedDescriptorResolver = DeserializedDescriptorResolver(RuntimeErrorReporter)
             val singleModuleClassResolver = SingleModuleClassResolver()
-            val runtimePackageFacadeProvider = RuntimePackageFacadeProvider(classLoader)
+            val runtimePackageFacadeProvider = RuntimePackagePartProvider(classLoader)
             val globalJavaResolverContext = JavaResolverComponents(
                     storageManager, ReflectJavaClassFinder(classLoader), reflectKotlinClassFinder, deserializedDescriptorResolver,
                     ExternalAnnotationResolver.EMPTY, ExternalSignatureResolver.DO_NOTHING, RuntimeErrorReporter, JavaResolverCache.EMPTY,

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

@@ -16,12 +16,12 @@
 
 package org.jetbrains.kotlin.load.kotlin.reflect
 
-import org.jetbrains.kotlin.descriptors.PackageFacadeProvider
+import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import java.io.InputStream
 import java.util.concurrent.ConcurrentHashMap
 
-class RuntimePackageFacadeProvider(val classLoader : ClassLoader) : PackageFacadeProvider {
+class RuntimePackagePartProvider(val classLoader : ClassLoader) : PackagePartProvider {
 
     val module2Mapping = ConcurrentHashMap<String, Lazy<ModuleMapping>>()
 
@@ -42,7 +42,7 @@ class RuntimePackageFacadeProvider(val classLoader : ClassLoader) : PackageFacad
     }
 
 
-    override fun findPackageFacades(packageInternalName: String): List<String> {
+    override fun findPackageParts(packageInternalName: String): List<String> {
         return module2Mapping.values().map { it.value.findPackageParts(packageInternalName) }.filterNotNull().flatMap { it.parts }.distinct()
     }
 }

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

@@ -16,13 +16,13 @@
 
 package org.jetbrains.kotlin.descriptors
 
-interface PackageFacadeProvider {
+interface PackagePartProvider {
 
-    fun findPackageFacades(packageInternalName: String): List<String>
+    fun findPackageParts(packageInternalName: String): List<String>
 
     companion object {
-        val EMPTY = object : PackageFacadeProvider {
+        val EMPTY = object : PackagePartProvider {
-            override fun findPackageFacades(packageInternalName: String): List<String> {
+            override fun findPackageParts(packageInternalName: String): List<String> {
                 return emptyList()
             }
         }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDEPackagePartProvider.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.descriptors.PackageFacadeProvider
+import org.jetbrains.kotlin.descriptors.PackagePartProvider
-import org.jetbrains.kotlin.load.kotlin.PackageFacades
+import org.jetbrains.kotlin.load.kotlin.PackageParts
 
-public class IDEPackageFacadeProvider(val scope: GlobalSearchScope) : PackageFacadeProvider {
+public class IDEPackagePartProvider(val scope: GlobalSearchScope) : PackagePartProvider {
 
-    override fun findPackageFacades(packageInternalName: String): List<String> {
+    override fun findPackageParts(packageInternalName: String): List<String> {
-        val values: MutableList<PackageFacades> = FileBasedIndex.getInstance().getValues(KotlinModuleMappingIndex.KEY, packageInternalName, scope)
+        val values: MutableList<PackageParts> = 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.descriptors.PackageFacadeProvider
+import org.jetbrains.kotlin.descriptors.PackagePartProvider
 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>,
-            packageFacadeProvider: PackageFacadeProvider
+            packagePartProvider: PackagePartProvider
     ): 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) -> IDEPackageFacadeProvider(c.moduleContentScope) }
+                { (m, c) -> IDEPackagePartProvider(c.moduleContentScope) }
         )
         return resolverForProject
     }

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

@@ -21,7 +21,7 @@ import com.intellij.util.indexing.*
 import com.intellij.util.io.DataExternalizer
 import com.intellij.util.io.KeyDescriptor
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
-import org.jetbrains.kotlin.load.kotlin.PackageFacades
+import org.jetbrains.kotlin.load.kotlin.PackageParts
 import java.io.DataInput
 import java.io.DataOutput
 
@@ -37,11 +37,11 @@ class PackageData(val data: List<String>) {
 }
 
 
-public object KotlinModuleMappingIndex : FileBasedIndexExtension<String, PackageFacades>() {
+public object KotlinModuleMappingIndex : FileBasedIndexExtension<String, PackageParts>() {
 
     private val classOfIndex = javaClass<KotlinModuleMappingIndex>().getCanonicalName()
 
-    public val KEY: ID<String, PackageFacades> = ID.create(classOfIndex)
+    public val KEY: ID<String, PackageParts> = ID.create(classOfIndex)
 
     private val KEY_DESCRIPTOR = object : KeyDescriptor<String> {
         override fun save(output: DataOutput, value: String) = output.writeUTF(value)
@@ -53,10 +53,10 @@ public object KotlinModuleMappingIndex : FileBasedIndexExtension<String, Package
         override fun isEqual(val1: String?, val2: String?) = val1 == val2
     }
 
-    private val VALUE_EXTERNALIZER = object : DataExternalizer<PackageFacades> {
+    private val VALUE_EXTERNALIZER = object : DataExternalizer<PackageParts> {
-        override fun read(`in`: DataInput): PackageFacades? {
+        override fun read(`in`: DataInput): PackageParts? {
             val internalName = `in`.readUTF()
-            val facades = PackageFacades(internalName)
+            val facades = PackageParts(internalName)
             val size = `in`.readInt()
             (1..size).forEach {
                 facades.parts.add(`in`.readUTF())
@@ -65,7 +65,7 @@ public object KotlinModuleMappingIndex : FileBasedIndexExtension<String, Package
             return facades
         }
 
-        override fun save(out: DataOutput, value: PackageFacades?) {
+        override fun save(out: DataOutput, value: PackageParts?) {
             out.writeUTF(value!!.packageInternalName)
             out.writeInt(value.parts.size())
             value.parts.forEach { out.writeUTF(it) }
@@ -88,12 +88,12 @@ public object KotlinModuleMappingIndex : FileBasedIndexExtension<String, Package
 
     override fun getVersion(): Int = 1
 
-    override fun getIndexer(): DataIndexer<String, PackageFacades, FileContent> {
+    override fun getIndexer(): DataIndexer<String, PackageParts, FileContent> {
-        return object : DataIndexer<String, PackageFacades, FileContent> {
+        return object : DataIndexer<String, PackageParts, FileContent> {
-            override fun map(inputData: FileContent): MutableMap<String, PackageFacades> {
+            override fun map(inputData: FileContent): MutableMap<String, PackageParts> {
                 val content = String(inputData.getContent())
                 val moduleMapping = ModuleMapping(content)
-                return moduleMapping.package2MiniFacades
+                return moduleMapping.package2Parts
             }
         }
     }

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

@@ -18,16 +18,17 @@ package org.jetbrains.kotlin.idea.decompiler.textBuilder
 
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.idea.caches.resolve.IDEPackagePartProvider
 import org.jetbrains.kotlin.idea.test.JetWithJdkAndRuntimeLightProjectDescriptor
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinder
+import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 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.idea.caches.resolve.IDEPackageFacadeProvider
-import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
 
@@ -49,7 +50,7 @@ public class DecompiledTextConsistencyTest : TextConsistencyBaseTest() {
             TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(
                     TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, "test"),
                     listOf(), BindingTraceContext(), null, null,
-                    IDEPackageFacadeProvider(GlobalSearchScope.allScope(project))
+                    IDEPackagePartProvider(GlobalSearchScope.allScope(project))
             ).moduleDescriptor
 
     override fun getProjectDescriptor() =