Simplify module configuration and built-ins dependency in some tests

- In tests on built-ins with no sources, just call
  JvmResolve.analyze(environment) and inspect the resulting module
- In AbstractLocalClassProtoTest, create container via
  TDAForJVM.createContainer
- Inline single module container creation into AbstractDiagnosticsTest

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

@@ -55,8 +55,7 @@ class CliReplAnalyzerEngine(environment: KotlinCoreEnvironment) {
                 trace,
                 environment.configuration,
                 { scope -> JvmPackagePartProvider(environment, scope) },
-                { storageManager, files -> ScriptMutableDeclarationProviderFactory() },
+                { storageManager, files -> ScriptMutableDeclarationProviderFactory() }
-                GlobalSearchScope.EMPTY_SCOPE
         )
 
         this.module = container.get<ModuleDescriptorImpl>()

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

@@ -20,7 +20,6 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
@@ -32,7 +31,6 @@ import org.jetbrains.kotlin.load.java.InternalFlexibleTypeTransformer
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
 import org.jetbrains.kotlin.load.java.components.*
 import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver
-import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
 import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl
 import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
 import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinderFactory
@@ -121,22 +119,6 @@ fun createContainerForTopDownAnalyzerForJvm(
 )
 
 
-fun createContainerForTopDownSingleModuleAnalyzerForJvm(
-        moduleContext: ModuleContext,
-        bindingTrace: BindingTrace,
-        declarationProviderFactory: DeclarationProviderFactory,
-        moduleContentScope: GlobalSearchScope,
-        packagePartProvider: PackagePartProvider,
-        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT
-): ComponentProvider = createContainerForTopDownAnalyzerForJvm(
-        moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope,
-        LookupTracker.DO_NOTHING, packagePartProvider, languageVersionSettings, SingleModuleClassResolver()
-).apply {
-    initJvmBuiltInsForTopDownAnalysis(moduleContext.module, languageVersionSettings)
-    get<SingleModuleClassResolver>().resolver = get<JavaDescriptorResolver>()
-}
-
-
 fun ComponentProvider.initJvmBuiltInsForTopDownAnalysis(module: ModuleDescriptor, languageVersionSettings: LanguageVersionSettings) {
     get<JvmBuiltIns>().initialize(module, languageVersionSettings.supportsFeature(LanguageFeature.AdditionalBuiltInsMembers))
 }

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

@@ -95,7 +95,7 @@ object TopDownAnalyzerFacadeForJVM {
             configuration: CompilerConfiguration,
             packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
             declarationProviderFactory: (StorageManager, Collection<KtFile>) -> DeclarationProviderFactory,
-            sourceModuleSearchScope: GlobalSearchScope
+            sourceModuleSearchScope: GlobalSearchScope = newModuleSearchScope(project, files)
     ): ComponentProvider {
         val moduleContext = createModuleContext(project, configuration)
 

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

@@ -23,12 +23,22 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.AnalyzingUtils
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
+import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
 
 object JvmResolveUtil {
+    @JvmStatic
+    @JvmOverloads
+    fun createContainer(environment: KotlinCoreEnvironment, files: Collection<KtFile> = emptyList()): ComponentProvider =
+            TopDownAnalyzerFacadeForJVM.createContainer(
+                    environment.project, files, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
+                    environment.configuration, { PackagePartProvider.Empty }, ::FileBasedDeclarationProviderFactory
+            )
+
     @JvmStatic
     fun analyzeAndCheckForErrors(file: KtFile, environment: KotlinCoreEnvironment): AnalysisResult =
             analyzeAndCheckForErrors(setOf(file), environment)

compiler/tests-java8/tests/org/jetbrains/kotlin/serialization/builtins/AdditionalBuiltInsMembersSignatureListsTest.kt

@@ -16,26 +16,17 @@
 
 package org.jetbrains.kotlin.serialization.builtins
 
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.context.ModuleContext
-import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.descriptors.resolveClassByFqName
-import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownSingleModuleAnalyzerForJvm
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.kotlin.JvmBuiltInsSettings
 import org.jetbrains.kotlin.load.kotlin.computeJvmDescriptor
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyPublicApi
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.test.ConfigurationKind
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
 import org.jetbrains.kotlin.test.TestJdkKind
 
@@ -45,16 +36,7 @@ class AdditionalBuiltInsMembersSignatureListsTest : KotlinTestWithEnvironment()
     }
 
     fun testAllListedSignaturesExistInJdk() {
-        val jvmBuiltIns = JvmBuiltIns(LockBasedStorageManager.NO_LOCKS)
+        val module = JvmResolveUtil.analyze(environment).moduleDescriptor as ModuleDescriptorImpl
-        val emptyModule = KotlinTestUtils.createEmptyModule("<empty>", jvmBuiltIns)
-
-        val container = createContainerForTopDownSingleModuleAnalyzerForJvm(
-                ModuleContext(emptyModule, environment.project), CliLightClassGenerationSupport.CliBindingTrace(),
-                DeclarationProviderFactory.EMPTY, GlobalSearchScope.allScope(environment.project), PackagePartProvider.Empty
-        )
-
-        emptyModule.initialize(container.get<JavaDescriptorResolver>().packageFragmentProvider)
-        emptyModule.setDependencies(emptyModule)
 
         val blackList =
                 JvmBuiltInsSettings.BLACK_LIST_METHOD_SIGNATURES +
@@ -69,7 +51,7 @@ class AdditionalBuiltInsMembersSignatureListsTest : KotlinTestWithEnvironment()
             it ->
             val (internalName, jvmDescriptors) = it
             val classDescriptor =
-                    emptyModule.resolveClassByFqName(
+                    module.resolveClassByFqName(
                             JvmClassName.byInternalName(internalName).fqNameForClassNameWithoutDollars, NoLookupLocation.FROM_TEST
                     )!!
 

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

@@ -48,6 +48,8 @@ import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.diagnostics.*;
 import org.jetbrains.kotlin.frontend.java.di.InjectionKt;
+import org.jetbrains.kotlin.incremental.components.LookupTracker;
+import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
@@ -301,6 +303,7 @@ public abstract class AbstractDiagnosticsTest extends BaseDiagnosticsTest {
         }
         else {
             configuration = getEnvironment().getConfiguration();
+            languageVersionSettings = LanguageVersionSettingsImpl.DEFAULT;
         }
 
         // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
@@ -326,14 +329,19 @@ public abstract class AbstractDiagnosticsTest extends BaseDiagnosticsTest {
         }
 
         GlobalSearchScope moduleContentScope = GlobalSearchScope.allScope(moduleContext.getProject());
-        ComponentProvider container = InjectionKt.createContainerForTopDownSingleModuleAnalyzerForJvm(
+        SingleModuleClassResolver moduleClassResolver = new SingleModuleClassResolver();
+        ComponentProvider container = InjectionKt.createContainerForTopDownAnalyzerForJvm(
                 moduleContext,
                 moduleTrace,
                 new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), files),
                 moduleContentScope,
+                LookupTracker.Companion.getDO_NOTHING(),
                 new JvmPackagePartProvider(getEnvironment(), moduleContentScope),
-                configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
+                languageVersionSettings,
+                moduleClassResolver
         );
+        InjectionKt.initJvmBuiltInsForTopDownAnalysis(container, moduleContext.getModule(), languageVersionSettings);
+        moduleClassResolver.setResolver(DslKt.getService(container, JavaDescriptorResolver.class));
 
         ModuleDescriptorImpl moduleDescriptor = (ModuleDescriptorImpl) moduleContext.getModule();
         moduleDescriptor.initialize(new CompositePackageFragmentProvider(Arrays.asList(

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

@@ -16,21 +16,16 @@
 
 package org.jetbrains.kotlin.serialization
 
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.container.get
-import org.jetbrains.kotlin.descriptors.PackagePartProvider
-import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownSingleModuleAnalyzerForJvm
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.structure.reflect.classId
 import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
+import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
-import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.test.*
 import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator
 import java.io.File
@@ -54,17 +49,15 @@ abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
         val clazz = classLoader.loadClass(classFile.toRelativeString(tmpdir).substringBeforeLast(".class").replace('/', '.').replace('\\', '.'))
         assertHasAnnotationData(clazz)
 
-        val configuration = KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir)
+        val configuration = KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir).apply {
+            // This is needed because otherwise local classes, being binary classes, are not resolved via source module's container.
+            // They could only be resolved via the container of the _dependency_ module.
+            // This can be improved as soon as there's an API to get the container of the dependency module.
+            put(JVMConfigurationKeys.USE_SINGLE_MODULE, true)
+        }
         val environment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
-        val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.project, configuration)
 
-        val container = createContainerForTopDownSingleModuleAnalyzerForJvm(
+        val components = JvmResolveUtil.createContainer(environment).get<DeserializationComponentsForJava>().components
-                moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), DeclarationProviderFactory.EMPTY,
-                GlobalSearchScope.allScope(environment.project), PackagePartProvider.Empty
-        )
-        moduleContext.initializeModuleContents(container.get<JavaDescriptorResolver>().packageFragmentProvider)
-
-        val components = container.get<DeserializationComponentsForJava>().components
 
         val classDescriptor = components.classDeserializer.deserializeClass(clazz.classId)
                               ?: error("Class is not resolved: $clazz (classId = ${clazz.classId})")

compiler/tests/org/jetbrains/kotlin/serialization/builtins/AbstractBuiltInsWithJDKMembersTest.kt

@@ -16,63 +16,43 @@
 
 package org.jetbrains.kotlin.serialization.builtins
 
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.builtins.BuiltInsPackageFragment
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns.*
-import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.context.ModuleContext
-import org.jetbrains.kotlin.descriptors.PackagePartProvider
-import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownSingleModuleAnalyzerForJvm
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
 import org.jetbrains.kotlin.renderer.OverrideRenderingPolicy
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
+import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.test.ConfigurationKind
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator
 import java.io.File
 
 abstract class AbstractBuiltInsWithJDKMembersTest : KotlinTestWithEnvironment() {
-    override fun createEnvironment(): KotlinCoreEnvironment {
+    private val configuration = RecursiveDescriptorComparator.RECURSIVE_ALL.includeMethodsOfKotlinAny(false).withRenderer(
-        return createEnvironmentWithJdk(ConfigurationKind.JDK_ONLY, TestJdkKind.FULL_JDK)
+            DescriptorRenderer.withOptions {
-    }
+                withDefinedIn = false
+                overrideRenderingPolicy = OverrideRenderingPolicy.RENDER_OPEN_OVERRIDE
+                verbose = true
+                includeAnnotationArguments = true
+                modifiers = DescriptorRendererModifier.ALL
+            })
+
+    override fun createEnvironment(): KotlinCoreEnvironment =
+            createEnvironmentWithJdk(ConfigurationKind.JDK_ONLY, TestJdkKind.FULL_JDK)
 
     protected fun doTest(builtinVersionName: String) {
-        val configuration = RecursiveDescriptorComparator.RECURSIVE_ALL.includeMethodsOfKotlinAny(false).withRenderer(
+        val module = JvmResolveUtil.analyze(environment).moduleDescriptor as ModuleDescriptorImpl
-                DescriptorRenderer.withOptions {
-                    withDefinedIn = false
-                    overrideRenderingPolicy = OverrideRenderingPolicy.RENDER_OPEN_OVERRIDE
-                    verbose = true
-                    includeAnnotationArguments = true
-                    modifiers = DescriptorRendererModifier.ALL
-                })
 
-        val jvmBuiltIns = JvmBuiltIns(LockBasedStorageManager.NO_LOCKS)
+        for (packageFqName in listOf(BUILT_INS_PACKAGE_FQ_NAME, COLLECTIONS_PACKAGE_FQ_NAME, RANGES_PACKAGE_FQ_NAME)) {
-        val emptyModule = KotlinTestUtils.createEmptyModule("<empty>", jvmBuiltIns)
+            val loaded =
-
+                    module.packageFragmentProvider.getPackageFragments(packageFqName).filterIsInstance<BuiltInsPackageFragment>().single()
-        val container = createContainerForTopDownSingleModuleAnalyzerForJvm(
-                ModuleContext(emptyModule, environment.project), CliLightClassGenerationSupport.CliBindingTrace(),
-                DeclarationProviderFactory.EMPTY, GlobalSearchScope.allScope(environment.project), PackagePartProvider.Empty
-        )
-
-        emptyModule.initialize(container.get<JavaDescriptorResolver>().packageFragmentProvider)
-        emptyModule.setDependencies(emptyModule)
-
-        val packageFragmentProvider = emptyModule.builtIns.builtInsModule.packageFragmentProvider
-
-        for (packageFqName in listOf<FqName>(BUILT_INS_PACKAGE_FQ_NAME, COLLECTIONS_PACKAGE_FQ_NAME, RANGES_PACKAGE_FQ_NAME)) {
-            val loaded = packageFragmentProvider.getPackageFragments(packageFqName).filterIsInstance<BuiltInsPackageFragment>().single()
             RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile(
                     loaded, configuration,
-                    File("compiler/testData/builtin-classes/$builtinVersionName/" + packageFqName.asString().replace('.', '-') + ".txt"))
+                    File("compiler/testData/builtin-classes/$builtinVersionName/" + packageFqName.asString().replace('.', '-') + ".txt")
+            )
         }
     }
 }