Do not inject CompilerConfiguration into compiler front-end

Inject LanguageVersionSettings instead; all information relevant to the
analysis should be now passed via an instance of LanguageVersionSettings
(which should be renamed to a more general name in the future).

This is partially a revert of d499998 and related commits

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/DefaultAnalyzerFacade.kt

@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.frontend.di.configureCommon
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.kotlin.MetadataFinderFactory
@@ -49,11 +48,9 @@ import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragmen
  * See [TargetPlatform.Default]
  */
 object DefaultAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
-    private val compilerConfiguration = CompilerConfiguration().apply {
-        languageVersionSettings = LanguageVersionSettingsImpl(
-                LanguageVersion.LATEST, ApiVersion.LATEST, additionalFeatures = setOf(LanguageFeature.MultiPlatformProjects)
-        )
-    }
+    private val languageVersionSettings = LanguageVersionSettingsImpl(
+            LanguageVersion.LATEST, ApiVersion.LATEST, additionalFeatures = setOf(LanguageFeature.MultiPlatformProjects)
+    )
 
     private class SourceModuleInfo(
             override val name: Name,
@@ -135,7 +132,7 @@ object DefaultAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
         useImpl<ResolveSession>()
         useImpl<LazyTopDownAnalyzer>()
         useImpl<FileScopeProviderImpl>()
-        configureCommon(compilerConfiguration)
+        useInstance(languageVersionSettings)
         useImpl<CompilerDeserializationConfiguration>()
         useInstance(packagePartProvider)
         useInstance(declarationProviderFactory)

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

@@ -16,9 +16,9 @@
 
 package org.jetbrains.kotlin.frontend.di
 
-import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.config.TargetPlatformVersion
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
@@ -73,18 +73,13 @@ fun StorageComponentContainer.configureModule(
     useInstance(trace)
 }
 
-fun StorageComponentContainer.configureCommon(configuration: CompilerConfiguration) {
-    useInstance(configuration)
-    useInstance(configuration.languageVersionSettings)
-}
-
 fun createContainerForBodyResolve(
         moduleContext: ModuleContext,
         bindingTrace: BindingTrace,
         platform: TargetPlatform,
         statementFilter: StatementFilter,
         targetPlatformVersion: TargetPlatformVersion,
-        compilerConfiguration: CompilerConfiguration
+        languageVersionSettings: LanguageVersionSettings
 ): StorageComponentContainer = createContainer("BodyResolve", platform) {
     configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
 
@@ -92,7 +87,7 @@ fun createContainerForBodyResolve(
 
     useInstance(LookupTracker.DO_NOTHING)
     useInstance(BodyResolveCache.ThrowException)
-    configureCommon(compilerConfiguration)
+    useInstance(languageVersionSettings)
 
     useImpl<BodyResolver>()
 }
@@ -104,7 +99,7 @@ fun createContainerForLazyBodyResolve(
         platform: TargetPlatform,
         bodyResolveCache: BodyResolveCache,
         targetPlatformVersion: TargetPlatformVersion,
-        compilerConfiguration: CompilerConfiguration
+        languageVersionSettings: LanguageVersionSettings
 ): StorageComponentContainer = createContainer("LazyBodyResolve", platform) {
     configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
 
@@ -112,7 +107,7 @@ fun createContainerForLazyBodyResolve(
     useInstance(kotlinCodeAnalyzer)
     useInstance(kotlinCodeAnalyzer.fileScopeProvider)
     useInstance(bodyResolveCache)
-    configureCommon(compilerConfiguration)
+    useInstance(languageVersionSettings)
     useImpl<LazyTopDownAnalyzer>()
     useImpl<BasicAbsentDescriptorHandler>()
 }
@@ -123,7 +118,7 @@ fun createContainerForLazyLocalClassifierAnalyzer(
         platform: TargetPlatform,
         lookupTracker: LookupTracker,
         targetPlatformVersion: TargetPlatformVersion,
-        compilerConfiguration: CompilerConfiguration,
+        languageVersionSettings: LanguageVersionSettings,
         statementFilter: StatementFilter,
         localClassDescriptorHolder: LocalClassDescriptorHolder
 ): StorageComponentContainer = createContainer("LocalClassifierAnalyzer", platform) {
@@ -143,7 +138,7 @@ fun createContainerForLazyLocalClassifierAnalyzer(
     useImpl<DeclarationScopeProviderForLocalClassifierAnalyzer>()
     useImpl<LocalLazyDeclarationResolver>()
 
-    configureCommon(compilerConfiguration)
+    useInstance(languageVersionSettings)
     useInstance(statementFilter)
 }
 
@@ -154,14 +149,13 @@ fun createContainerForLazyResolve(
         platform: TargetPlatform,
         targetPlatformVersion: TargetPlatformVersion,
         targetEnvironment: TargetEnvironment,
-        compilerConfiguration: CompilerConfiguration
+        languageVersionSettings: LanguageVersionSettings
 ): StorageComponentContainer = createContainer("LazyResolve", platform) {
     configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
 
     useInstance(declarationProviderFactory)
     useInstance(LookupTracker.DO_NOTHING)
-
-    configureCommon(compilerConfiguration)
+    useInstance(languageVersionSettings)
 
     useImpl<FileScopeProviderImpl>()
     useImpl<CompilerDeserializationConfiguration>()
@@ -179,5 +173,5 @@ fun createLazyResolveSession(moduleContext: ModuleContext, files: Collection<KtF
                 TargetPlatform.Default,
                 TargetPlatformVersion.NoVersion,
                 CompilerEnvironment,
-                CompilerConfiguration.EMPTY
+                LanguageVersionSettingsImpl.DEFAULT
         ).get<ResolveSession>()

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt

@@ -61,8 +61,7 @@ class CallCompleter(
         private val dataFlowAnalyzer: DataFlowAnalyzer,
         private val callCheckers: Iterable<CallChecker>,
         private val builtIns: KotlinBuiltIns,
-        private val languageVersionSettings: LanguageVersionSettings,
-        private val compilerConfiguration: CompilerConfiguration
+        private val languageVersionSettings: LanguageVersionSettings
 ) {
     fun <D : CallableDescriptor> completeCall(
             context: BasicCallResolutionContext,
@@ -93,7 +92,7 @@ class CallCompleter(
                     if (calleeExpression != null && !calleeExpression.isFakeElement) calleeExpression
                     else resolvedCall.call.callElement
 
-            val callCheckerContext = CallCheckerContext(context, languageVersionSettings, compilerConfiguration)
+            val callCheckerContext = CallCheckerContext(context, languageVersionSettings)
             for (callChecker in callCheckers) {
                 callChecker.check(resolvedCall, reportOn, callCheckerContext)
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CallChecker.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.resolve.calls.checkers
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
@@ -38,8 +37,7 @@ interface CallChecker {
 class CallCheckerContext(
         val resolutionContext: ResolutionContext<*>,
         val trace: BindingTrace,
-        val languageVersionSettings: LanguageVersionSettings,
-        val compilerConfiguration: CompilerConfiguration
+        val languageVersionSettings: LanguageVersionSettings
 ) {
     val scope: LexicalScope
         get() = resolutionContext.scope
@@ -50,7 +48,7 @@ class CallCheckerContext(
     val isAnnotationContext: Boolean
         get() = resolutionContext.isAnnotationContext
 
-    constructor(c: ResolutionContext<*>, languageVersionSettings: LanguageVersionSettings, configuration: CompilerConfiguration) : this(c, c.trace, languageVersionSettings, configuration)
+    constructor(c: ResolutionContext<*>, languageVersionSettings: LanguageVersionSettings) : this(c, c.trace, languageVersionSettings)
 }
 
 // Use this utility to avoid premature computation of deferred return type of a resolved callable descriptor.

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java

@@ -687,8 +687,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         trace.record(CALL, expression, call);
 
         if (context.trace.wantsDiagnostics()) {
-            CallCheckerContext callCheckerContext =
-                    new CallCheckerContext(context, components.languageVersionSettings, components.compilerConfiguration);
+            CallCheckerContext callCheckerContext = new CallCheckerContext(context, components.languageVersionSettings);
             for (CallChecker checker : components.callCheckers) {
                 checker.check(resolvedCall, expression, callCheckerContext);
             }
@@ -996,8 +995,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 if (resolvedCall != null && trace.wantsDiagnostics()) {
                     // Call must be validated with the actual, not temporary trace in order to report operator diagnostic
                     // Only unary assignment expressions (++, --) and +=/... must be checked, normal assignments have the proper trace
-                    CallCheckerContext callCheckerContext =
-                            new CallCheckerContext(context, trace, components.languageVersionSettings, components.compilerConfiguration);
+                    CallCheckerContext callCheckerContext = new CallCheckerContext(context, trace, components.languageVersionSettings);
                     for (CallChecker checker : components.callCheckers) {
                         checker.check(resolvedCall, expression, callCheckerContext);
                     }
@@ -1064,8 +1062,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         resolvedCall.markCallAsCompleted();
 
         if (context.trace.wantsDiagnostics()) {
-            CallCheckerContext callCheckerContext =
-                    new CallCheckerContext(context, components.languageVersionSettings, components.compilerConfiguration);
+            CallCheckerContext callCheckerContext = new CallCheckerContext(context, components.languageVersionSettings);
             for (CallChecker checker : components.callCheckers) {
                 checker.check(resolvedCall, expression, callCheckerContext);
             }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.types.expressions;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.LanguageVersionSettings;
 import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.incremental.components.LookupTracker;
@@ -61,7 +60,6 @@ public class ExpressionTypingComponents {
     /*package*/ OverloadChecker overloadChecker;
     /*package*/ LanguageVersionSettings languageVersionSettings;
     /*package*/ Iterable<RttiExpressionChecker> rttiExpressionCheckers;
-    /*package*/ CompilerConfiguration compilerConfiguration;
 
     @Inject
     public void setGlobalContext(@NotNull GlobalContext globalContext) {
@@ -202,9 +200,4 @@ public class ExpressionTypingComponents {
     public void setRttiExpressionCheckers(@NotNull Iterable<RttiExpressionChecker> rttiExpressionCheckers) {
         this.rttiExpressionCheckers = rttiExpressionCheckers;
     }
-
-    @Inject
-    public void setCompilerConfiguration(CompilerConfiguration compilerConfiguration) {
-        this.compilerConfiguration = compilerConfiguration;
-    }
 }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt

@@ -64,7 +64,7 @@ class LocalClassifierAnalyzer(
         private val lookupTracker: LookupTracker,
         private val supertypeLoopChecker: SupertypeLoopChecker,
         private val targetPlatformVersion: TargetPlatformVersion,
-        private val compilerConfiguration: CompilerConfiguration,
+        private val languageVersionSettings: LanguageVersionSettings,
         private val delegationFilter: DelegationFilter
 ) {
     fun processClassOrObject(
@@ -82,7 +82,7 @@ class LocalClassifierAnalyzer(
                 platform,
                 lookupTracker,
                 targetPlatformVersion,
-                compilerConfiguration,
+                languageVersionSettings,
                 context.statementFilter,
                 LocalClassDescriptorHolder(
                         scope,
@@ -96,7 +96,7 @@ class LocalClassifierAnalyzer(
                         typeResolver,
                         annotationResolver,
                         supertypeLoopChecker,
-                        compilerConfiguration.languageVersionSettings,
+                        languageVersionSettings,
                         SyntheticResolveExtension.getInstance(project),
                         delegationFilter
                 )