From ee1152bc98bbbda2d4f34041e636c5bacc89911f Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 10 Feb 2017 18:56:57 +0300 Subject: [PATCH] Simplify injection of LanguageVersionSettings into JVM analysis Pass the LanguageVersionSettings instance inside the CompilerConfiguration, since it's needed anyway. In compiler and tests, the configuration comes from KotlinCoreEnvironment; in IDE, we're constructing it in JvmAnalyzerFacade --- .../kotlin/frontend/java/di/injection.kt | 28 ++++++++----------- .../kotlin/resolve/jvm/JvmAnalyzerFacade.kt | 27 ++++++++++-------- .../jvm/TopDownAnalyzerFacadeForJVM.kt | 6 ++-- .../checkers/AbstractDiagnosticsTest.kt | 24 ++++++---------- 4 files changed, 39 insertions(+), 46 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt index f094382263d..a3e7cf15c63 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt @@ -19,9 +19,7 @@ package org.jetbrains.kotlin.frontend.java.di import com.intellij.openapi.project.Project import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.builtins.JvmBuiltInsPackageFragmentProvider -import org.jetbrains.kotlin.config.CompilerConfiguration -import org.jetbrains.kotlin.config.LanguageFeature -import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.container.* import org.jetbrains.kotlin.context.LazyResolveToken import org.jetbrains.kotlin.context.ModuleContext @@ -46,11 +44,10 @@ import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory -fun StorageComponentContainer.configureJavaTopDownAnalysis( +private fun StorageComponentContainer.configureJavaTopDownAnalysis( moduleContentScope: GlobalSearchScope, project: Project, - lookupTracker: LookupTracker, - languageVersionSettings: LanguageVersionSettings + lookupTracker: LookupTracker ) { useInstance(moduleContentScope) useInstance(lookupTracker) @@ -75,7 +72,6 @@ fun StorageComponentContainer.configureJavaTopDownAnalysis( useImpl() useInstance(InternalFlexibleTypeTransformer) - useInstance(languageVersionSettings) useImpl() } @@ -88,19 +84,20 @@ fun createContainerForLazyResolveWithJava( targetEnvironment: TargetEnvironment, lookupTracker: LookupTracker, packagePartProvider: PackagePartProvider, - languageVersionSettings: LanguageVersionSettings, + compilerConfiguration: CompilerConfiguration, useBuiltInsProvider: Boolean, - useLazyResolve: Boolean, - compilerConfiguration: CompilerConfiguration + useLazyResolve: Boolean ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatform) { configureModule(moduleContext, JvmPlatform, bindingTrace) - configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker, languageVersionSettings) + configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker) useInstance(compilerConfiguration) useInstance(packagePartProvider) useInstance(moduleClassResolver) useInstance(declarationProviderFactory) + useInstance(compilerConfiguration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)) + if (useBuiltInsProvider) { useInstance((moduleContext.module.builtIns as JvmBuiltIns).settings) useImpl() @@ -123,18 +120,17 @@ fun createContainerForTopDownAnalyzerForJvm( moduleContentScope: GlobalSearchScope, lookupTracker: LookupTracker, packagePartProvider: PackagePartProvider, - languageVersionSettings: LanguageVersionSettings, moduleClassResolver: ModuleClassResolver, compilerConfiguration: CompilerConfiguration ): ComponentProvider = createContainerForLazyResolveWithJava( moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, moduleClassResolver, - CompilerEnvironment, lookupTracker, packagePartProvider, languageVersionSettings, - useBuiltInsProvider = true, useLazyResolve = false, compilerConfiguration = compilerConfiguration + CompilerEnvironment, lookupTracker, packagePartProvider, compilerConfiguration, + useBuiltInsProvider = true, useLazyResolve = false ) -fun ComponentProvider.initJvmBuiltInsForTopDownAnalysis(module: ModuleDescriptor, languageVersionSettings: LanguageVersionSettings) { - get().initialize(module, languageVersionSettings) +fun ComponentProvider.initJvmBuiltInsForTopDownAnalysis() { + get().initialize(get(), get()) } internal fun JvmBuiltIns.initialize(module: ModuleDescriptor, languageVersionSettings: LanguageVersionSettings) { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt index 34367bc1601..d4b005d8e40 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.resolve.jvm import com.intellij.openapi.diagnostic.Logger import com.intellij.psi.search.GlobalSearchScope 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 @@ -81,15 +82,20 @@ object JvmAnalyzerFacade : AnalyzerFacade() { resolverForModule.componentProvider.get() } - val languageSettingsProvider = LanguageSettingsProvider.getInstance(project) - val trace = CodeAnalyzerInitializer.getInstance(project).createTrace() - //TODO: need to propagate full CompilerConfiguration to frontend - val compilerConfiguration = CompilerConfiguration() - val platform = languageSettingsProvider.getTargetPlatform(moduleInfo) - if (platform is JvmTarget) { - compilerConfiguration.put(JVMConfigurationKeys.JVM_TARGET, platform) + val configuration = CompilerConfiguration().apply { + val languageSettingsProvider = LanguageSettingsProvider.getInstance(project) + put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project)) + + val platform = languageSettingsProvider.getTargetPlatform(moduleInfo) + if (platform is JvmTarget) { + put(JVMConfigurationKeys.JVM_TARGET, platform) + } + + isReadOnly = true } - compilerConfiguration.isReadOnly = true + + val trace = CodeAnalyzerInitializer.getInstance(project).createTrace() + val container = createContainerForLazyResolveWithJava( moduleContext, trace, @@ -99,10 +105,9 @@ object JvmAnalyzerFacade : AnalyzerFacade() { targetEnvironment, LookupTracker.DO_NOTHING, packagePartProvider, - languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project), + configuration, useBuiltInsProvider = false, // TODO: load built-ins from module dependencies in IDE - useLazyResolve = true, - compilerConfiguration = compilerConfiguration + useLazyResolve = true ) StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(container, moduleInfo) } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.kt index 1b8c4aa2d8c..9a0db027b70 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.kt @@ -158,7 +158,7 @@ object TopDownAnalyzerFacadeForJVM { val dependenciesContainer = createContainerForTopDownAnalyzerForJvm( dependenciesContext, trace, DeclarationProviderFactory.EMPTY, dependencyScope, lookupTracker, - packagePartProvider(dependencyScope), languageVersionSettings, moduleClassResolver, configuration + packagePartProvider(dependencyScope), moduleClassResolver, configuration ) StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(dependenciesContainer, null) } @@ -185,9 +185,9 @@ object TopDownAnalyzerFacadeForJVM { // TODO: get rid of duplicate invocation of CodeAnalyzerInitializer#initialize, or refactor CliLightClassGenerationSupport val container = createContainerForTopDownAnalyzerForJvm( moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, lookupTracker, - partProvider, languageVersionSettings, moduleClassResolver, configuration + partProvider, moduleClassResolver, configuration ).apply { - initJvmBuiltInsForTopDownAnalysis(module, languageVersionSettings) + initJvmBuiltInsForTopDownAnalysis() (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get() StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(this, null) } diff --git a/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt b/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt index 90a983c9429..b3e1c137f93 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt @@ -24,10 +24,8 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult import org.jetbrains.kotlin.analyzer.common.DefaultAnalyzerFacade import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport 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.CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS import org.jetbrains.kotlin.config.LanguageVersionSettings -import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.context.ModuleContext import org.jetbrains.kotlin.context.SimpleGlobalContext @@ -260,17 +258,12 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() { ): AnalysisResult { @Suppress("NAME_SHADOWING") var files = files - @Suppress("NAME_SHADOWING") - var languageVersionSettings = languageVersionSettings - val configuration: CompilerConfiguration - if (languageVersionSettings != null) { - configuration = environment.configuration.copy() - configuration.put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageVersionSettings) - } - else { - configuration = environment.configuration - languageVersionSettings = LanguageVersionSettingsImpl.DEFAULT - } + + val configuration = + if (languageVersionSettings != null) + environment.configuration.copy().apply { put(LANGUAGE_VERSION_SETTINGS, languageVersionSettings) } + else + environment.configuration // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module, // albeit with same class names @@ -318,11 +311,10 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() { moduleContentScope, LookupTracker.DO_NOTHING, JvmPackagePartProvider(environment, moduleContentScope), - languageVersionSettings, moduleClassResolver, configuration ) - container.initJvmBuiltInsForTopDownAnalysis(moduleDescriptor, languageVersionSettings) + container.initJvmBuiltInsForTopDownAnalysis() moduleClassResolver.resolver = container.get() moduleDescriptor.initialize(CompositePackageFragmentProvider(listOf(