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/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.jvm.TopDownAnalyzerFacadeForJVM
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 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(
-                moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), DeclarationProviderFactory.EMPTY,
-                GlobalSearchScope.allScope(environment.project), PackagePartProvider.Empty
-        )
-        moduleContext.initializeModuleContents(container.get<JavaDescriptorResolver>().packageFragmentProvider)
-
-        val components = container.get<DeserializationComponentsForJava>().components
+        val components = JvmResolveUtil.createContainer(environment).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.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.descriptors.impl.ModuleDescriptorImpl
 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.declarations.DeclarationProviderFactory
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 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 {
-        return createEnvironmentWithJdk(ConfigurationKind.JDK_ONLY, TestJdkKind.FULL_JDK)
-    }
+    private val configuration = RecursiveDescriptorComparator.RECURSIVE_ALL.includeMethodsOfKotlinAny(false).withRenderer(
+            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(
-                DescriptorRenderer.withOptions {
-                    withDefinedIn = false
-                    overrideRenderingPolicy = OverrideRenderingPolicy.RENDER_OPEN_OVERRIDE
-                    verbose = true
-                    includeAnnotationArguments = true
-                    modifiers = DescriptorRendererModifier.ALL
-                })
+        val module = JvmResolveUtil.analyze(environment).moduleDescriptor as ModuleDescriptorImpl
 
-        val jvmBuiltIns = JvmBuiltIns(LockBasedStorageManager.NO_LOCKS)
-        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 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()
+        for (packageFqName in listOf(BUILT_INS_PACKAGE_FQ_NAME, COLLECTIONS_PACKAGE_FQ_NAME, RANGES_PACKAGE_FQ_NAME)) {
+            val loaded =
+                    module.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")
+            )
         }
     }
 }