Pass GlobalSearchScope instance to JvmPackagePartProvider

Currently behavior is unchanged because the "all project" scope is passed,
however in the future this will allow to implement separate modules in the
compiler properly

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.cli.jvm.compiler
 
+import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.util.SmartList
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
@@ -23,12 +24,15 @@ import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import java.io.EOFException
 
-class JvmPackagePartProvider(val env: KotlinCoreEnvironment) : PackagePartProvider {
+class JvmPackagePartProvider(
+        private val env: KotlinCoreEnvironment,
+        private val scope: GlobalSearchScope
+) : PackagePartProvider {
     private val notLoadedRoots by lazy(LazyThreadSafetyMode.NONE) {
         env.configuration.getList(JVMConfigurationKeys.CONTENT_ROOTS)
                 .filterIsInstance<JvmClasspathRoot>()
                 .mapNotNull { env.contentRootToVirtualFile(it) }
-                .filter { it.findChild("META-INF") != null }
+                .filter { it in scope && it.findChild("META-INF") != null }
                 .toMutableList()
     }
 

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

@@ -408,7 +408,7 @@ object KotlinToJVMBytecodeCompiler {
                             environment.getSourceFiles(),
                             CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                             environment.configuration,
-                            JvmPackagePartProvider(environment)
+                            { scope -> JvmPackagePartProvider(environment, scope) }
                     )
 
             override fun reportEnvironmentErrors() {

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/CliReplAnalyzerEngine.kt

@@ -54,12 +54,13 @@ class CliReplAnalyzerEngine(environment: KotlinCoreEnvironment) {
 
         this.scriptDeclarationFactory = ScriptMutableDeclarationProviderFactory()
 
+        val moduleContentScope = ProjectScope.getAllScope(environment.project)
         val container = createContainerForTopDownSingleModuleAnalyzerForJvm(
                 moduleContext,
                 trace,
                 scriptDeclarationFactory,
-                ProjectScope.getAllScope(environment.project),
-                JvmPackagePartProvider(environment)
+                moduleContentScope,
+                JvmPackagePartProvider(environment, moduleContentScope)
         )
 
         this.resolveSession = container.get<ResolveSession>()

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

@@ -58,7 +58,7 @@ object TopDownAnalyzerFacadeForJVM {
             files: Collection<KtFile>,
             trace: BindingTrace,
             configuration: CompilerConfiguration,
-            packagePartProvider: PackagePartProvider
+            packagePartProviderFactory: (GlobalSearchScope) -> PackagePartProvider
     ): AnalysisResult {
         val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, configuration)
         val storageManager = moduleContext.storageManager
@@ -76,13 +76,16 @@ object TopDownAnalyzerFacadeForJVM {
             }
         }
 
+        val sourceScope = GlobalSearchScope.allScope(project)
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext,
                 trace,
                 FileBasedDeclarationProviderFactory(storageManager, files),
-                GlobalSearchScope.allScope(project),
+                sourceScope,
                 lookupTracker,
-                IncrementalPackagePartProvider.create(packagePartProvider, targetIds, incrementalComponents, storageManager),
+                IncrementalPackagePartProvider.create(
+                        packagePartProviderFactory(sourceScope), targetIds, incrementalComponents, storageManager
+                ),
                 configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT),
                 ModuleClassResolverImpl(resolverByClass)
         )

compiler/tests-common/org/jetbrains/kotlin/codegen/GenerationUtils.kt

@@ -39,10 +39,11 @@ object GenerationUtils {
 
     @JvmStatic
     fun compileFiles(files: List<KtFile>, environment: KotlinCoreEnvironment?): GenerationState {
-        val packagePartProvider = if (environment == null) PackagePartProvider.Empty else JvmPackagePartProvider(environment)
         val configuration = environment?.configuration ?: KotlinTestUtils.newConfiguration()
 
-        val analysisResult = JvmResolveUtil.analyzeAndCheckForErrors(files.first().project, files, configuration, packagePartProvider)
+        val analysisResult = JvmResolveUtil.analyzeAndCheckForErrors(files.first().project, files, configuration) { scope ->
+            if (environment == null) PackagePartProvider.Empty else JvmPackagePartProvider(environment, scope)
+        }
         analysisResult.throwIfError()
 
         val state = GenerationState(

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

@@ -18,7 +18,9 @@ package org.jetbrains.kotlin.jvm.compiler;
 
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.psi.search.GlobalSearchScope;
 import junit.framework.ComparisonFailure;
+import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
@@ -29,10 +31,7 @@ import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.ContentRootsKt;
 import org.jetbrains.kotlin.config.JVMConfigurationKeys;
-import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
+import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
@@ -155,12 +154,17 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         JvmContentRootsKt.addJavaSourceRoot(configuration, new File("compiler/testData/loadJava/include"));
         JvmContentRootsKt.addJavaSourceRoot(configuration, tmpdir);
 
-        KotlinCoreEnvironment environment =
+        final KotlinCoreEnvironment environment =
                 KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
         AnalysisResult result = TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
                 environment.getProject(), environment.getSourceFiles(), new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                configuration, new JvmPackagePartProvider(environment)
+                configuration, new Function1<GlobalSearchScope, PackagePartProvider>() {
+                    @Override
+                    public PackagePartProvider invoke(GlobalSearchScope scope) {
+                        return new JvmPackagePartProvider(environment, scope);
+                    }
+                }
         );
 
         PackageViewDescriptor packageView = result.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME);

compiler/tests-common/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.resolve.lazy
 
 import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
@@ -34,14 +35,16 @@ object JvmResolveUtil {
 
     @JvmStatic
     fun analyzeAndCheckForErrors(files: Collection<KtFile>, environment: KotlinCoreEnvironment): AnalysisResult =
-            analyzeAndCheckForErrors(environment.project, files, environment.configuration, JvmPackagePartProvider(environment))
+            analyzeAndCheckForErrors(environment.project, files, environment.configuration) { scope ->
+                JvmPackagePartProvider(environment, scope)
+            }
 
     @JvmStatic
     fun analyzeAndCheckForErrors(
             project: Project,
             files: Collection<KtFile>,
             configuration: CompilerConfiguration,
-            packagePartProvider: PackagePartProvider
+            packagePartProvider: (GlobalSearchScope) -> PackagePartProvider
     ): AnalysisResult {
         for (file in files) {
             AnalyzingUtils.checkForSyntacticErrors(file)
@@ -62,16 +65,18 @@ object JvmResolveUtil {
 
     @JvmStatic
     fun analyze(files: Collection<KtFile>, environment: KotlinCoreEnvironment): AnalysisResult =
-            analyze(environment.project, files, environment.configuration, JvmPackagePartProvider(environment))
+            analyze(environment.project, files, environment.configuration) { scope ->
+                JvmPackagePartProvider(environment, scope)
+            }
 
     private fun analyze(
             project: Project,
             files: Collection<KtFile>,
             configuration: CompilerConfiguration,
-            packagePartProvider: PackagePartProvider
+            packagePartProviderFactory: (GlobalSearchScope) -> PackagePartProvider
     ): AnalysisResult {
         return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                project, files, CliLightClassGenerationSupport.CliBindingTrace(), configuration, packagePartProvider
+                project, files, CliLightClassGenerationSupport.CliBindingTrace(), configuration, packagePartProviderFactory
         )
     }
 }

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

@@ -283,12 +283,13 @@ public abstract class AbstractDiagnosticsTest extends BaseDiagnosticsTest {
         // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
         // albeit with same class names
         // See TopDownAnalyzerFacadeForJVM#analyzeFilesWithJavaIntegration
+        GlobalSearchScope moduleContentScope = GlobalSearchScope.allScope(moduleContext.getProject());
         ComponentProvider container = InjectionKt.createContainerForTopDownSingleModuleAnalyzerForJvm(
                 moduleContext,
                 moduleTrace,
                 new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), files),
-                GlobalSearchScope.allScope(moduleContext.getProject()),
-                new JvmPackagePartProvider(getEnvironment()),
+                moduleContentScope,
+                new JvmPackagePartProvider(getEnvironment(), moduleContentScope),
                 configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
         );
 

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

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.idea.decompiler.textBuilder
 
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
@@ -49,8 +48,7 @@ class DecompiledTextConsistencyTest : TextConsistencyBaseTest() {
 
     override fun getModuleDescriptor(): ModuleDescriptor =
             TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                    project, listOf(), BindingTraceContext(), KotlinTestUtils.newConfiguration(),
-                    IDEPackagePartProvider(GlobalSearchScope.allScope(project))
+                    project, listOf(), BindingTraceContext(), KotlinTestUtils.newConfiguration(), ::IDEPackagePartProvider
             ).moduleDescriptor
 
     override fun getProjectDescriptor() =