Move module creation into TopDownAnalyzerFacadeForJVM#analyzeFilesWithJavaIntegration

The only place where the logic has changed is in AbstractDiagnosticsTest, where
modules are already created and sealed before the analysis. Copy-paste the
container creation logic there (it's almost fine because it's also present in a
bunch of other tests), and simplify it: get rid of incremental compilation and
other stuff irrelevant for diagnostic tests.

This is needed to make analyzeFilesWithJavaIntegration configure the module
properly before sealing it

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

@@ -17,9 +17,9 @@
 package org.jetbrains.kotlin.cli.jvm.compiler
 
 import com.intellij.openapi.util.io.JarUtil
-import org.jetbrains.annotations.TestOnly
 import com.intellij.psi.PsiManager
 import com.intellij.psi.impl.PsiModificationTrackerImpl
+import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.asJava.FilteredJvmDiagnostics
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection
@@ -29,15 +29,11 @@ import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.common.messages.*
 import org.jetbrains.kotlin.cli.common.output.outputUtils.writeAll
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
-import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoot
+import org.jetbrains.kotlin.cli.jvm.config.*
-import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot
-import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories
 import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.GeneratedClassLoader
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
-import org.jetbrains.kotlin.cli.jvm.config.*
-import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.codegen.state.GenerationStateEventCallback
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -406,19 +402,14 @@ object KotlinToJVMBytecodeCompiler {
         val analyzerWithCompilerReport = AnalyzerWithCompilerReport(collector)
         analyzerWithCompilerReport.analyzeAndReport(
                 environment.getSourceFiles(), object : AnalyzerWithCompilerReport.Analyzer {
-            override fun analyze(): AnalysisResult {
+            override fun analyze(): AnalysisResult =
-                val sharedTrace = CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace()
+                    TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                val moduleContext =
+                            environment.project,
-                        TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.project, environment.configuration)
+                            environment.getSourceFiles(),
-
+                            CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
+                            environment.configuration,
-                        moduleContext,
+                            JvmPackagePartProvider(environment)
-                        environment.getSourceFiles(),
+                    )
-                        sharedTrace,
-                        environment.configuration,
-                        JvmPackagePartProvider(environment)
-                )
-            }
 
             override fun reportEnvironmentErrors() {
                 reportRuntimeConflicts(collector, environment.configuration.jvmClasspathRoots)

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

@@ -128,10 +128,11 @@ fun createContainerForTopDownSingleModuleAnalyzerForJvm(
         bindingTrace: BindingTrace,
         declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope,
-        packagePartProvider: PackagePartProvider
+        packagePartProvider: PackagePartProvider,
+        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT
 ): ComponentProvider = createContainerForTopDownAnalyzerForJvm(
         moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope,
-        LookupTracker.DO_NOTHING, packagePartProvider, LanguageVersionSettingsImpl.DEFAULT, SingleModuleClassResolver()
+        LookupTracker.DO_NOTHING, packagePartProvider, languageVersionSettings, SingleModuleClassResolver()
 ).apply {
     get<SingleModuleClassResolver>().resolver = get<JavaDescriptorResolver>()
 }

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

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ContextForNewModule
-import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.MutableModuleContext
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
@@ -53,14 +52,14 @@ import java.util.*
 object TopDownAnalyzerFacadeForJVM {
     @JvmStatic
     fun analyzeFilesWithJavaIntegration(
-            moduleContext: ModuleContext,
+            project: Project,
             files: Collection<KtFile>,
             trace: BindingTrace,
             configuration: CompilerConfiguration,
             packagePartProvider: PackagePartProvider
     ): AnalysisResult {
+        val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, configuration)
         val storageManager = moduleContext.storageManager
-        val project = moduleContext.project
         val module = moduleContext.module
 
         val incrementalComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)
@@ -114,7 +113,6 @@ object TopDownAnalyzerFacadeForJVM {
         return AnalysisResult.success(trace.bindingContext, module)
     }
 
-    @JvmStatic
     fun createContextWithSealedModule(project: Project, configuration: CompilerConfiguration): MutableModuleContext {
         val projectContext = ProjectContext(project)
         val builtIns = JvmBuiltIns(projectContext.storageManager)

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

@@ -20,6 +20,7 @@ import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.io.FileUtil;
 import junit.framework.ComparisonFailure;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
@@ -28,14 +29,12 @@ 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.context.ModuleContext;
 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.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
@@ -155,19 +154,17 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         ContentRootsKt.addKotlinSourceRoot(configuration, sourcesDir.getAbsolutePath());
         JvmContentRootsKt.addJavaSourceRoot(configuration, new File("compiler/testData/loadJava/include"));
         JvmContentRootsKt.addJavaSourceRoot(configuration, tmpdir);
-        
+
         KotlinCoreEnvironment environment =
                 KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
-        BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
+        AnalysisResult result = TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-        ModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.getProject(), configuration);
+                environment.getProject(), environment.getSourceFiles(), new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-
+                configuration, new JvmPackagePartProvider(environment)
-        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                moduleContext, environment.getSourceFiles(), trace, configuration, new JvmPackagePartProvider(environment)
         );
 
-        PackageViewDescriptor packageView = moduleContext.getModule().getPackage(TEST_PACKAGE_FQNAME);
+        PackageViewDescriptor packageView = result.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME);
-        checkJavaPackage(expectedFile, packageView, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT);
+        checkJavaPackage(expectedFile, packageView, result.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT);
     }
 
     // TODO: add more tests on inherited parameter names, but currently impossible because of KT-4509

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

@@ -88,8 +88,7 @@ public class JvmResolveUtil {
             @NotNull PackagePartProvider packagePartProvider
     ) {
         return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-                TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, configuration),
+                project, files, new CliLightClassGenerationSupport.CliBindingTrace(), configuration, packagePartProvider
-                files, new CliLightClassGenerationSupport.CliBindingTrace(), configuration, packagePartProvider
         );
     }
 }

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

@@ -22,6 +22,7 @@ import com.google.common.collect.Sets;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiElement;
+import com.intellij.psi.search.GlobalSearchScope;
 import kotlin.collections.CollectionsKt;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
@@ -32,6 +33,9 @@ import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.LanguageVersionSettings;
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl;
+import org.jetbrains.kotlin.container.ComponentProvider;
+import org.jetbrains.kotlin.container.DslKt;
 import org.jetbrains.kotlin.context.ContextKt;
 import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.context.ModuleContext;
@@ -40,6 +44,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.diagnostics.*;
+import org.jetbrains.kotlin.frontend.java.di.InjectionKt;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
@@ -48,15 +53,13 @@ import org.jetbrains.kotlin.psi.Call;
 import org.jetbrains.kotlin.psi.KtElement;
 import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.KtFile;
-import org.jetbrains.kotlin.resolve.AnalyzingUtils;
+import org.jetbrains.kotlin.resolve.*;
-import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.TargetPlatformKt;
 import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
-import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
+import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
+import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.kotlin.storage.ExceptionTracker;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.storage.StorageManager;
@@ -277,9 +280,22 @@ 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
-        return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
+        // See TopDownAnalyzerFacadeForJVM#analyzeFilesWithJavaIntegration
-                moduleContext, files, moduleTrace, configuration, new JvmPackagePartProvider(getEnvironment())
+        ComponentProvider container = InjectionKt.createContainerForTopDownSingleModuleAnalyzerForJvm(
+                moduleContext,
+                moduleTrace,
+                new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), files),
+                GlobalSearchScope.allScope(moduleContext.getProject()),
+                new JvmPackagePartProvider(getEnvironment()),
+                configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
         );
+
+        DslKt.getService(container, LazyTopDownAnalyzerForTopLevel.class).analyzeFiles(
+                TopDownAnalysisMode.TopLevelDeclarations, files,
+                Collections.singletonList(DslKt.getService(container, JavaDescriptorResolver.class).getPackageFragmentProvider())
+        );
+
+        return AnalysisResult.success(moduleTrace.getBindingContext(), moduleContext.getModule());
     }
 
     private void validateAndCompareDescriptorWithFile(

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

@@ -47,13 +47,11 @@ class DecompiledTextConsistencyTest : TextConsistencyBaseTest() {
     override fun getDecompiledText(packageFile: VirtualFile, resolver: ResolverForDecompiler?): String =
             (resolver?.let { buildDecompiledTextForClassFile(packageFile, it) } ?: buildDecompiledTextForClassFile(packageFile)).text
 
-    override fun getModuleDescriptor(): ModuleDescriptor {
+    override fun getModuleDescriptor(): ModuleDescriptor =
-        val configuration = KotlinTestUtils.newConfiguration()
+            TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
-        return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
+                    project, listOf(), BindingTraceContext(), KotlinTestUtils.newConfiguration(),
-                TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, configuration), listOf(), BindingTraceContext(),
+                    IDEPackagePartProvider(GlobalSearchScope.allScope(project))
-                configuration, IDEPackagePartProvider(GlobalSearchScope.allScope(project))
+            ).moduleDescriptor
-        ).moduleDescriptor
-    }
 
     override fun getProjectDescriptor() =
             object : KotlinWithJdkAndRuntimeLightProjectDescriptor() {