Refactor createContainerForLazyResolve/createLazyResolveSession

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.frontend.di
 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.StorageComponentContainer
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
@@ -27,9 +28,11 @@ import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
 import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.lazy.*
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
 import org.jetbrains.kotlin.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer
 import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorHolder
 import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver
@@ -137,17 +140,15 @@ fun createContainerForLazyResolve(
         bindingTrace: BindingTrace,
         platform: TargetPlatform,
         targetEnvironment: TargetEnvironment,
-        languageVersionSettings: LanguageVersionSettings
+        compilerConfiguration: CompilerConfiguration
 ): StorageComponentContainer = createContainer("LazyResolve", platform) {
     configureModule(moduleContext, platform, bindingTrace)
 
     useInstance(declarationProviderFactory)
     useInstance(LookupTracker.DO_NOTHING)
-    useInstance(languageVersionSettings)
-    //TODO: need to propagate full CompilerConfiguration to frontend
-    useInstance(CompilerConfiguration().apply {
-        put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageVersionSettings)
-    })
+    useInstance(compilerConfiguration)
+
+    useInstance(compilerConfiguration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT))
 
     useImpl<FileScopeProviderImpl>()
     useImpl<CompilerDeserializationConfiguration>()
@@ -157,14 +158,12 @@ fun createContainerForLazyResolve(
     useImpl<ResolveSession>()
 }
 
-@JvmOverloads
-fun createLazyResolveSession(
-        moduleContext: ModuleContext,
-        declarationProviderFactory: DeclarationProviderFactory,
-        bindingTrace: BindingTrace,
-        platform: TargetPlatform,
-        languageVersionSettings: LanguageVersionSettings,
-        targetEnvironment: TargetEnvironment = CompilerEnvironment
-): ResolveSession = createContainerForLazyResolve(
-        moduleContext, declarationProviderFactory, bindingTrace, platform, targetEnvironment, languageVersionSettings
-).get<ResolveSession>()
+fun createLazyResolveSession(moduleContext: ModuleContext, files: Collection<KtFile>): ResolveSession =
+        createContainerForLazyResolve(
+                moduleContext,
+                FileBasedDeclarationProviderFactory(moduleContext.storageManager, files),
+                BindingTraceContext(),
+                TargetPlatform.Default,
+                CompilerEnvironment,
+                CompilerConfiguration.EMPTY
+        ).get<ResolveSession>()

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

@@ -20,7 +20,7 @@ import com.intellij.openapi.editor.impl.DocumentImpl
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
+import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -62,7 +62,7 @@ abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
                 CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                 JvmPlatform,
                 targetEnvironment,
-                LanguageVersionSettingsImpl.DEFAULT
+                CompilerConfiguration.EMPTY
         )
 
         val resolveSession = container.get<ResolveSession>()
@@ -148,12 +148,10 @@ abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
         val renderedDescriptors = descriptors.map { renderer.render(it) }.joinToString(separator = "\n")
 
         val document = DocumentImpl(psiFile.text)
-        KtUsefulTestCase.assertSameLines(KotlinTestUtils.getLastCommentedLines(document), renderedDescriptors.toString())
+        KtUsefulTestCase.assertSameLines(KotlinTestUtils.getLastCommentedLines(document), renderedDescriptors)
     }
 
     override fun createEnvironment(): KotlinCoreEnvironment {
         return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY)
     }
 }
-
-

compiler/tests/org/jetbrains/kotlin/types/DefaultModalityModifiersTest.java

@@ -21,18 +21,17 @@ import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl;
 import org.jetbrains.kotlin.context.ContextKt;
-import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.BindingContext;
+import org.jetbrains.kotlin.resolve.DescriptorResolver;
+import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfoFactory;
 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.resolve.scopes.*;
 import org.jetbrains.kotlin.resolve.scopes.utils.ScopeUtilsKt;
 import org.jetbrains.kotlin.test.ConfigurationKind;
@@ -104,14 +103,9 @@ public class DefaultModalityModifiersTest extends KotlinTestWithEnvironment {
         }
 
         private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, KtClass aClass) {
-            ModuleContext moduleContext = ContextKt.ModuleContext(root, getProject());
             ResolveSession resolveSession = createLazyResolveSession(
-                    moduleContext,
-                    new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(),
-                                                            Collections.singleton(aClass.getContainingKtFile())),
-                    new BindingTraceContext(),
-                    TargetPlatform.Default.INSTANCE,
-                    LanguageVersionSettingsImpl.DEFAULT
+                    ContextKt.ModuleContext(root, getProject()),
+                    Collections.singleton(aClass.getContainingKtFile())
             );
 
             return (ClassDescriptorWithResolutionScopes) resolveSession.getClassDescriptor(aClass, NoLookupLocation.FROM_TEST);

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt

@@ -20,6 +20,10 @@ import com.intellij.openapi.roots.OrderRootType
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.util.PathUtil
 import org.jetbrains.kotlin.analyzer.*
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
@@ -55,13 +59,20 @@ object JsAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
                 project, moduleContext.storageManager, syntheticFiles, if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope
         )
 
+        // TODO: deduplicate this with JvmAnalyzerFacade
+        val configuration = CompilerConfiguration().apply {
+            val languageSettingsProvider = LanguageSettingsProvider.getInstance(project)
+            put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project))
+            isReadOnly = true
+        }
+
         val container = createContainerForLazyResolve(
                 moduleContext,
                 declarationProviderFactory,
                 BindingTraceContext(),
                 JsPlatform,
                 targetEnvironment,
-                LanguageSettingsProvider.getInstance(project).getLanguageVersionSettings(moduleInfo, project)
+                configuration
         )
         var packageFragmentProvider = container.get<ResolveSession>().packageFragmentProvider
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/SourceNavigationHelper.java

@@ -42,7 +42,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns;
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl;
 import org.jetbrains.kotlin.context.ContextKt;
 import org.jetbrains.kotlin.context.MutableModuleContext;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
@@ -55,11 +54,8 @@ import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.BindingTraceContext;
-import org.jetbrains.kotlin.resolve.TargetPlatform;
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
-import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -235,26 +231,12 @@ public class SourceNavigationHelper {
             @NotNull Collection<KtNamedDeclaration> candidates,
             @NotNull Project project
     ) {
-        MutableModuleContext newModuleContext = ContextKt.ContextForNewModule(
+        MutableModuleContext context = ContextKt.ContextForNewModule(
                 ContextKt.ProjectContext(project), Name.special("<library module>"), DefaultBuiltIns.getInstance(), null
         );
-
-        newModuleContext.setDependencies(newModuleContext.getModule(), newModuleContext.getModule().getBuiltIns().getBuiltInsModule());
-
-        FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(
-                newModuleContext.getStorageManager(),
-                getContainingFiles(candidates)
-        );
-
-        ResolveSession resolveSession = InjectionKt.createLazyResolveSession(
-                newModuleContext,
-                providerFactory,
-                new BindingTraceContext(),
-                TargetPlatform.Default.INSTANCE,
-                LanguageVersionSettingsImpl.DEFAULT
-        );
-
-        newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider());
+        context.setDependencies(context.getModule(), context.getModule().getBuiltIns().getBuiltInsModule());
+        ResolveSession resolveSession = InjectionKt.createLazyResolveSession(context, getContainingFiles(candidates));
+        context.initializeModuleContents(resolveSession.getPackageFragmentProvider());
         return resolveSession;
     }
 
@@ -453,7 +435,7 @@ public class SourceNavigationHelper {
     }
 
     @NotNull
-    public static KtDeclaration navigateToDeclaration(
+    private static KtDeclaration navigateToDeclaration(
             @NotNull KtDeclaration from,
             @NotNull NavigationKind navigationKind
     ) {