[Injection] Minor: inline createContainerForTopDownAnalyzerForJvm

Essentially, this function was used solely for setting
'useBuiltInsProvider' to 'true'; otherwise it were just delegating to
createContainerForLazyResolveWithJava, which were just increasing the
noise.

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

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
-import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
+import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava
 import org.jetbrains.kotlin.frontend.java.di.initJvmBuiltInsForTopDownAnalysis
 import org.jetbrains.kotlin.frontend.java.di.initialize
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
@@ -167,11 +167,13 @@ object TopDownAnalyzerFacadeForJVM {
             // Scope for the dependency module contains everything except files present in the scope for the source module
             val dependencyScope = GlobalSearchScope.notScope(sourceScope)
 
-            val dependenciesContainer = createContainerForTopDownAnalyzerForJvm(
-                JvmPlatforms.jvmPlatformByTargetVersion(jvmTarget), // TODO(dsavvinov): do not pass JvmTarget around
-                dependenciesContext, trace, DeclarationProviderFactory.EMPTY, dependencyScope, lookupTracker, expectActualTracker,
-                packagePartProvider(dependencyScope), moduleClassResolver, targetEnvironment, languageVersionSettings,
-                configureJavaClassFinder
+            val dependenciesContainer = createContainerForLazyResolveWithJava(
+                JvmPlatforms.jvmPlatformByTargetVersion(jvmTarget),
+                dependenciesContext, trace, DeclarationProviderFactory.EMPTY, dependencyScope, moduleClassResolver,
+                targetEnvironment, lookupTracker, expectActualTracker,
+                packagePartProvider(dependencyScope), languageVersionSettings,
+                useBuiltInsProvider = true,
+                configureJavaClassFinder = configureJavaClassFinder
             )
 
             moduleClassResolver.compiledCodeResolver = dependenciesContainer.get()
@@ -197,11 +199,14 @@ object TopDownAnalyzerFacadeForJVM {
         // CliLightClassGenerationSupport#initialize is invoked when container is created, so only the last module descriptor is going
         // to be stored in CliLightClassGenerationSupport, and it better be the source one (otherwise light classes would not be found)
         // TODO: get rid of duplicate invocation of CodeAnalyzerInitializer#initialize, or refactor CliLightClassGenerationSupport
-        val container = createContainerForTopDownAnalyzerForJvm(
+        val container = createContainerForLazyResolveWithJava(
             JvmPlatforms.jvmPlatformByTargetVersion(jvmTarget),
-            moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, lookupTracker, expectActualTracker,
-            partProvider, moduleClassResolver, targetEnvironment, languageVersionSettings, configureJavaClassFinder,
-            configuration[JVMConfigurationKeys.JAVA_CLASSES_TRACKER]
+            moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, moduleClassResolver,
+            targetEnvironment, lookupTracker, expectActualTracker,
+            partProvider, languageVersionSettings,
+            useBuiltInsProvider = true,
+            configureJavaClassFinder = configureJavaClassFinder,
+            javaClassTracker = configuration[JVMConfigurationKeys.JAVA_CLASSES_TRACKER]
         ).apply {
             initJvmBuiltInsForTopDownAnalysis()
             (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get()

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

@@ -118,29 +118,6 @@ fun createContainerForLazyResolveWithJava(
 }
 
 
-fun createContainerForTopDownAnalyzerForJvm(
-    jvmPlatform: TargetPlatform,
-    moduleContext: ModuleContext,
-    bindingTrace: BindingTrace,
-    declarationProviderFactory: DeclarationProviderFactory,
-    moduleContentScope: GlobalSearchScope,
-    lookupTracker: LookupTracker,
-    expectActualTracker: ExpectActualTracker,
-    packagePartProvider: PackagePartProvider,
-    moduleClassResolver: ModuleClassResolver,
-    targetEnvironment: TargetEnvironment,
-    languageVersionSettings: LanguageVersionSettings,
-    configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null,
-    javaClassTracker: JavaClassesTracker? = null
-): ComponentProvider = createContainerForLazyResolveWithJava(
-    jvmPlatform, moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, moduleClassResolver,
-    targetEnvironment, lookupTracker, expectActualTracker, packagePartProvider, languageVersionSettings,
-    useBuiltInsProvider = true,
-    configureJavaClassFinder = configureJavaClassFinder,
-    javaClassTracker = javaClassTracker
-)
-
-
 fun ComponentProvider.initJvmBuiltInsForTopDownAnalysis() {
     get<JvmBuiltIns>().initialize(get<ModuleDescriptor>(), get<LanguageVersionSettings>())
 }

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

@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.diagnostics.Errors.*
-import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
+import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava
 import org.jetbrains.kotlin.frontend.java.di.initJvmBuiltInsForTopDownAnalysis
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -380,18 +380,18 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
         val moduleContentScope = GlobalSearchScope.allScope(moduleContext.project)
         val moduleClassResolver = SingleModuleClassResolver()
 
-        val container = createContainerForTopDownAnalyzerForJvm(
+        val container = createContainerForLazyResolveWithJava(
             JvmPlatforms.jvmPlatformByTargetVersion(jvmTarget), // TODO(dsavvinov): do not pass JvmTarget around
             moduleContext,
             moduleTrace,
             FileBasedDeclarationProviderFactory(moduleContext.storageManager, files),
             moduleContentScope,
-            LookupTracker.DO_NOTHING,
+            moduleClassResolver,
+            CompilerEnvironment, LookupTracker.DO_NOTHING,
             ExpectActualTracker.DoNothing,
             environment.createPackagePartProvider(moduleContentScope),
-            moduleClassResolver,
-            CompilerEnvironment,
-            languageVersionSettings
+            languageVersionSettings,
+            useBuiltInsProvider = true
         )
 
         container.initJvmBuiltInsForTopDownAnalysis()