Use JvmResolveUtil.createContainer in AbstractDescriptorRendererTest

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

@@ -56,9 +56,7 @@ import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackagePartProvid
 import org.jetbrains.kotlin.modules.TargetId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
-import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
+import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
@@ -82,7 +80,8 @@ object TopDownAnalyzerFacadeForJVM {
         sourceModuleSearchScope: GlobalSearchScope = newModuleSearchScope(project, files)
     ): AnalysisResult {
         val container = createContainer(
-            project, files, trace, configuration, packagePartProvider, declarationProviderFactory, sourceModuleSearchScope
+            project, files, trace, configuration, packagePartProvider, declarationProviderFactory, CompilerEnvironment,
+            sourceModuleSearchScope
         )
 
         val module = container.get<ModuleDescriptor>()
@@ -122,6 +121,7 @@ object TopDownAnalyzerFacadeForJVM {
         configuration: CompilerConfiguration,
         packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
         declarationProviderFactory: (StorageManager, Collection<KtFile>) -> DeclarationProviderFactory,
+        targetEnvironment: TargetEnvironment = CompilerEnvironment,
         sourceModuleSearchScope: GlobalSearchScope = newModuleSearchScope(project, files)
     ): ComponentProvider {
         val createBuiltInsFromModule = configuration.getBoolean(JVMConfigurationKeys.CREATE_BUILT_INS_FROM_MODULE_DEPENDENCIES)
@@ -172,7 +172,8 @@ object TopDownAnalyzerFacadeForJVM {
 
             val dependenciesContainer = createContainerForTopDownAnalyzerForJvm(
                 dependenciesContext, trace, DeclarationProviderFactory.EMPTY, dependencyScope, lookupTracker, expectActualTracker,
-                packagePartProvider(dependencyScope), moduleClassResolver, jvmTarget, languageVersionSettings, configureJavaClassFinder
+                packagePartProvider(dependencyScope), moduleClassResolver, targetEnvironment, jvmTarget, languageVersionSettings,
+                configureJavaClassFinder
             )
 
             moduleClassResolver.compiledCodeResolver = dependenciesContainer.get()
@@ -200,8 +201,8 @@ object TopDownAnalyzerFacadeForJVM {
         // TODO: get rid of duplicate invocation of CodeAnalyzerInitializer#initialize, or refactor CliLightClassGenerationSupport
         val container = createContainerForTopDownAnalyzerForJvm(
             moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, lookupTracker, expectActualTracker,
-            partProvider, moduleClassResolver, jvmTarget, languageVersionSettings, configureJavaClassFinder,
-            javaClassTracker = configuration[JVMConfigurationKeys.JAVA_CLASSES_TRACKER]
+            partProvider, moduleClassResolver, targetEnvironment, jvmTarget, languageVersionSettings, configureJavaClassFinder,
+            configuration[JVMConfigurationKeys.JAVA_CLASSES_TRACKER]
         ).apply {
             initJvmBuiltInsForTopDownAnalysis()
             (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get()
@@ -270,12 +271,6 @@ object TopDownAnalyzerFacadeForJVM {
         }
     }
 
-    fun createContextWithSealedModule(project: Project, configuration: CompilerConfiguration): MutableModuleContext =
-        createModuleContext(project, configuration, false).apply {
-            setDependencies(module, module.builtIns.builtInsModule)
-            (module.builtIns as JvmBuiltIns).initialize(module, configuration.languageVersionSettings)
-        }
-
     private fun createModuleContext(
         project: Project,
         configuration: CompilerConfiguration,

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

@@ -140,13 +140,14 @@ fun createContainerForTopDownAnalyzerForJvm(
         expectActualTracker: ExpectActualTracker,
         packagePartProvider: PackagePartProvider,
         moduleClassResolver: ModuleClassResolver,
+        targetEnvironment: TargetEnvironment,
         jvmTarget: JvmTarget,
         languageVersionSettings: LanguageVersionSettings,
         configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null,
         javaClassTracker: JavaClassesTracker? = null
 ): ComponentProvider = createContainerForLazyResolveWithJava(
         moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, moduleClassResolver,
-        CompilerEnvironment, lookupTracker, expectActualTracker, packagePartProvider, jvmTarget, languageVersionSettings,
+        targetEnvironment, lookupTracker, expectActualTracker, packagePartProvider, jvmTarget, languageVersionSettings,
         useBuiltInsProvider = true,
         configureJavaClassFinder = configureJavaClassFinder,
         javaClassTracker = javaClassTracker

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt

@@ -383,6 +383,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
             ExpectActualTracker.DoNothing,
             environment.createPackagePartProvider(moduleContentScope),
             moduleClassResolver,
+            CompilerEnvironment,
             jvmTarget,
             languageVersionSettings
         )

compiler/tests-common/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt

@@ -19,23 +19,14 @@ package org.jetbrains.kotlin.renderer
 import com.intellij.openapi.editor.impl.DocumentImpl
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
-import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
-import org.jetbrains.kotlin.config.JvmTarget
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.frontend.di.createContainerForLazyResolve
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.TargetEnvironment
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
@@ -55,21 +46,8 @@ abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
         val fileText = FileUtil.loadFile(File(path), true)
         val psiFile = KtPsiFactory(project).createFile(fileText)
 
-        val context = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, environment.configuration)
-
-        val container = createContainerForLazyResolve(
-            context,
-            FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
-            NoScopeRecordCliBindingTrace(),
-            JvmPlatform,
-            JvmTarget.JVM_1_6,
-            targetEnvironment,
-            LanguageVersionSettingsImpl.DEFAULT
-        )
-
-        val resolveSession = container.get<ResolveSession>()
-
-        context.initializeModuleContents(resolveSession.packageFragmentProvider)
+        val container = JvmResolveUtil.createContainer(environment, listOf(psiFile), targetEnvironment)
+        val module = container.get<ModuleDescriptor>()
 
         val descriptors = ArrayList<DeclarationDescriptor>()
 
@@ -77,8 +55,7 @@ abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
             override fun visitKtFile(file: KtFile) {
                 val fqName = file.packageFqName
                 if (!fqName.isRoot) {
-                    val packageDescriptor = context.module.getPackage(fqName)
-                    descriptors.add(packageDescriptor)
+                    descriptors.add(module.getPackage(fqName))
                 }
                 file.acceptChildren(this)
             }

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

@@ -30,15 +30,22 @@ import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.AnalyzingUtils
 import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
+import org.jetbrains.kotlin.resolve.TargetEnvironment
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
 
 object JvmResolveUtil {
     @JvmStatic
     @JvmOverloads
-    fun createContainer(environment: KotlinCoreEnvironment, files: Collection<KtFile> = emptyList()): ComponentProvider =
+    fun createContainer(
+        environment: KotlinCoreEnvironment,
+        files: Collection<KtFile> = emptyList(),
+        targetEnvironment: TargetEnvironment = CompilerEnvironment
+    ): ComponentProvider =
         TopDownAnalyzerFacadeForJVM.createContainer(
             environment.project, files, NoScopeRecordCliBindingTrace(),
-            environment.configuration, { PackagePartProvider.Empty }, ::FileBasedDeclarationProviderFactory
+            environment.configuration, { PackagePartProvider.Empty }, ::FileBasedDeclarationProviderFactory,
+            targetEnvironment
         )
 
     @JvmStatic