Support "-language-version" CLI option for compatibility with older releases

Introduce LanguageFeatureSettings, instance of which should be injected by the
container and be accessible everywhere during the compilation (front-end and
back-end).

Parameters of LanguageFeatureSettings are unused in this commit, will be used
later

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.java

@@ -25,6 +25,10 @@ import java.util.List;
 public abstract class CommonCompilerArguments {
     public static final String PLUGIN_OPTION_FORMAT = "plugin:<pluginId>:<optionName>=<value>";
 
+    @Argument(value = "language-version", description = "Provide source compatibility with specified language version")
+    @ValueDescription("<version>")
+    public String languageVersion;
+
     @Argument(value = "nowarn", description = "Generate no warnings")
     public boolean suppressWarnings;
 

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.java

@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CompileEnvironmentException;
 import org.jetbrains.kotlin.cli.jvm.compiler.CompilerJarLocator;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
+import org.jetbrains.kotlin.config.LanguageFeatureSettings;
 import org.jetbrains.kotlin.config.Services;
 import org.jetbrains.kotlin.progress.CompilationCanceledException;
 import org.jetbrains.kotlin.progress.CompilationCanceledStatus;
@@ -242,6 +243,13 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> {
         if (locator != null) {
             configuration.put(CLIConfigurationKeys.COMPILER_JAR_LOCATOR, locator);
         }
+
+        if (arguments.languageVersion != null) {
+            configuration.put(
+                    CommonConfigurationKeys.LANGUAGE_FEATURE_SETTINGS,
+                    LanguageFeatureSettings.fromLanguageVersion(arguments.languageVersion)
+            );
+        }
     }
 
     protected abstract void setupPlatformSpecificArgumentsAndServices(

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.cli.jvm.repl.di
 
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
@@ -43,7 +44,7 @@ fun createContainerForReplWithJava(
 ): ContainerForReplWithJava = createContainer("ReplWithJava") {
     useInstance(packagePartProvider)
     configureModule(moduleContext, JvmPlatform, bindingTrace)
-    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING)
+    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING, LanguageFeatureSettings.LATEST)
 
     useInstance(declarationProviderFactory)
 

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

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.frontend.java.di
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
@@ -41,7 +42,12 @@ import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 
-fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentScope: GlobalSearchScope, project: Project, lookupTracker: LookupTracker) {
+fun StorageComponentContainer.configureJavaTopDownAnalysis(
+        moduleContentScope: GlobalSearchScope,
+        project: Project,
+        lookupTracker: LookupTracker,
+        languageFeatureSettings: LanguageFeatureSettings
+) {
     useInstance(moduleContentScope)
     useInstance(lookupTracker)
     useImpl<ResolveSession>()
@@ -65,19 +71,26 @@ fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentScope: G
     useImpl<JavaSourceElementFactoryImpl>()
     useImpl<JavaLazyAnalyzerPostConstruct>()
     useInstance(InternalFlexibleTypeTransformer)
+
+    useInstance(languageFeatureSettings)
 }
 
 fun createContainerForLazyResolveWithJava(
-        moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
+        moduleContext: ModuleContext,
-        moduleContentScope: GlobalSearchScope, moduleClassResolver: ModuleClassResolver,
+        bindingTrace: BindingTrace,
+        declarationProviderFactory: DeclarationProviderFactory,
+        moduleContentScope: GlobalSearchScope,
+        moduleClassResolver: ModuleClassResolver,
         targetEnvironment: TargetEnvironment = CompilerEnvironment,
-        packagePartProvider: PackagePartProvider
+        packagePartProvider: PackagePartProvider,
+        languageFeatureSettings: LanguageFeatureSettings
 ): ComponentProvider = createContainer("LazyResolveWithJava") {
     //TODO: idea specific code
     useInstance(packagePartProvider)
 
     configureModule(moduleContext, JvmPlatform, bindingTrace)
-    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING)
+
+    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING, languageFeatureSettings)
 
     useInstance(moduleClassResolver)
 
@@ -97,12 +110,13 @@ fun createContainerForTopDownAnalyzerForJvm(
         declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope,
         lookupTracker: LookupTracker,
-        packagePartProvider: PackagePartProvider
+        packagePartProvider: PackagePartProvider,
+        languageFeatureSettings: LanguageFeatureSettings
 ): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm") {
     useInstance(packagePartProvider)
 
     configureModule(moduleContext, JvmPlatform, bindingTrace)
-    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker)
+    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker, languageFeatureSettings)
 
     useInstance(declarationProviderFactory)
 

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

@@ -20,6 +20,7 @@ import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.*
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
@@ -89,7 +90,8 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
                 moduleContentScope,
                 moduleClassResolver,
                 targetEnvironment,
-                packagePartProvider
+                packagePartProvider,
+                LanguageFeatureSettings.LATEST // TODO: see KT-12410
         )
         val resolveSession = container.get<ResolveSession>()
         val javaDescriptorResolver = container.get<JavaDescriptorResolver>()

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

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.JVMConfigurationKeys;
+import org.jetbrains.kotlin.config.LanguageFeatureSettings;
 import org.jetbrains.kotlin.context.ContextKt;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.context.MutableModuleContext;
@@ -76,7 +77,9 @@ public enum TopDownAnalyzerFacadeForJVM {
         IncrementalCompilationComponents incrementalCompilationComponents =
                 configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS);
         LookupTracker lookupTracker =
-                incrementalCompilationComponents != null ? incrementalCompilationComponents.getLookupTracker() : LookupTracker.Companion.getDO_NOTHING();
+                incrementalCompilationComponents != null
+                ? incrementalCompilationComponents.getLookupTracker()
+                : LookupTracker.Companion.getDO_NOTHING();
 
         List<TargetId> targetIds = null;
         List<Module> modules = configuration.get(JVMConfigurationKeys.MODULES);
@@ -88,7 +91,9 @@ public enum TopDownAnalyzerFacadeForJVM {
             }
         }
 
-        packagePartProvider = IncrementalPackagePartProvider.create(packagePartProvider, files, targetIds, incrementalCompilationComponents, moduleContext.getStorageManager());
+        packagePartProvider = IncrementalPackagePartProvider.create(
+                packagePartProvider, files, targetIds, incrementalCompilationComponents, moduleContext.getStorageManager()
+        );
 
         ContainerForTopDownAnalyzerForJvm container = InjectionKt.createContainerForTopDownAnalyzerForJvm(
                 moduleContext,
@@ -96,7 +101,8 @@ public enum TopDownAnalyzerFacadeForJVM {
                 providerFactory,
                 GlobalSearchScope.allScope(project),
                 lookupTracker,
-                packagePartProvider
+                packagePartProvider,
+                configuration.get(CommonConfigurationKeys.LANGUAGE_FEATURE_SETTINGS, LanguageFeatureSettings.LATEST)
         );
 
         List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();

compiler/frontend/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.java

@@ -20,6 +20,9 @@ public class CommonConfigurationKeys {
     private CommonConfigurationKeys() {
     }
 
+    public static final CompilerConfigurationKey<LanguageFeatureSettings> LANGUAGE_FEATURE_SETTINGS =
+            CompilerConfigurationKey.create("language feature settings");
+
     public static final CompilerConfigurationKey<Boolean> DISABLE_INLINE =
             CompilerConfigurationKey.create("disable inline");
 

compiler/frontend/src/org/jetbrains/kotlin/config/LanguageFeatureSettings.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.config
+
+class LanguageFeatureSettings(
+        val typeAliases: Boolean = true,
+        val localDelegatedProperties: Boolean = true,
+        val topLevelSealedInheritance: Boolean = true
+) {
+    companion object {
+        private val SETTINGS = mapOf(
+                "1.0" to LanguageFeatureSettings(
+                        typeAliases = false,
+                        localDelegatedProperties = false,
+                        topLevelSealedInheritance = false
+                ),
+                "1.1" to LanguageFeatureSettings()
+        )
+
+        private val LATEST_VERSION = "1.1"
+
+        @JvmField
+        val LATEST: LanguageFeatureSettings = fromLanguageVersion(LATEST_VERSION)!!
+
+        @JvmStatic
+        fun fromLanguageVersion(source: String): LanguageFeatureSettings? = SETTINGS[source]
+    }
+}

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.frontend.di
 
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
@@ -61,8 +62,11 @@ fun StorageComponentContainer.configureModule(
 }
 
 fun createContainerForBodyResolve(
-        moduleContext: ModuleContext, bindingTrace: BindingTrace,
+        moduleContext: ModuleContext,
-        platform: TargetPlatform, statementFilter: StatementFilter
+        bindingTrace: BindingTrace,
+        platform: TargetPlatform,
+        statementFilter: StatementFilter,
+        languageFeatureSettings: LanguageFeatureSettings
 ): StorageComponentContainer = createContainer("BodyResolve") {
     configureModule(moduleContext, platform, bindingTrace)
 
@@ -70,21 +74,26 @@ fun createContainerForBodyResolve(
 
     useInstance(LookupTracker.DO_NOTHING)
     useInstance(BodyResolveCache.ThrowException)
+    useInstance(languageFeatureSettings)
 
     useImpl<BodyResolver>()
 }
 
 fun createContainerForLazyBodyResolve(
-        moduleContext: ModuleContext, kotlinCodeAnalyzer: KotlinCodeAnalyzer,
+        moduleContext: ModuleContext,
-        bindingTrace: BindingTrace, platform: TargetPlatform,
+        kotlinCodeAnalyzer: KotlinCodeAnalyzer,
-        bodyResolveCache: BodyResolveCache
+        bindingTrace: BindingTrace,
+        platform: TargetPlatform,
+        bodyResolveCache: BodyResolveCache,
+        languageFeatureSettings: LanguageFeatureSettings
 ): StorageComponentContainer = createContainer("LazyBodyResolve") {
     configureModule(moduleContext, platform, bindingTrace)
 
     useInstance(LookupTracker.DO_NOTHING)
     useInstance(kotlinCodeAnalyzer)
-    useInstance(kotlinCodeAnalyzer.getFileScopeProvider())
+    useInstance(kotlinCodeAnalyzer.fileScopeProvider)
     useInstance(bodyResolveCache)
+    useInstance(languageFeatureSettings)
     useImpl<LazyTopDownAnalyzerForTopLevel>()
     useImpl<BasicAbsentDescriptorHandler>()
 }
@@ -94,6 +103,7 @@ fun createContainerForLazyLocalClassifierAnalyzer(
         bindingTrace: BindingTrace,
         platform: TargetPlatform,
         lookupTracker: LookupTracker,
+        languageFeatureSettings: LanguageFeatureSettings,
         localClassDescriptorHolder: LocalClassDescriptorHolder
 ): StorageComponentContainer = createContainer("LocalClassifierAnalyzer") {
     configureModule(moduleContext, platform, bindingTrace)
@@ -111,6 +121,8 @@ fun createContainerForLazyLocalClassifierAnalyzer(
 
     useImpl<DeclarationScopeProviderForLocalClassifierAnalyzer>()
     useImpl<LocalLazyDeclarationResolver>()
+
+    useInstance(languageFeatureSettings)
 }
 
 fun createContainerForLazyResolve(
@@ -118,12 +130,14 @@ fun createContainerForLazyResolve(
         declarationProviderFactory: DeclarationProviderFactory,
         bindingTrace: BindingTrace,
         platform: TargetPlatform,
-        targetEnvironment: TargetEnvironment
+        targetEnvironment: TargetEnvironment,
+        languageFeatureSettings: LanguageFeatureSettings
 ): StorageComponentContainer = createContainer("LazyResolve") {
     configureModule(moduleContext, platform, bindingTrace)
 
     useInstance(declarationProviderFactory)
     useInstance(LookupTracker.DO_NOTHING)
+    useInstance(languageFeatureSettings)
 
     useImpl<FileScopeProviderImpl>()
     targetEnvironment.configure(this)
@@ -132,10 +146,14 @@ fun createContainerForLazyResolve(
     useImpl<ResolveSession>()
 }
 
-@JvmOverloads fun createLazyResolveSession(
+@JvmOverloads
+fun createLazyResolveSession(
         moduleContext: ModuleContext,
         declarationProviderFactory: DeclarationProviderFactory,
         bindingTrace: BindingTrace,
         platform: TargetPlatform,
+        languageFeatureSettings: LanguageFeatureSettings,
         targetEnvironment: TargetEnvironment = CompilerEnvironment
-): ResolveSession = createContainerForLazyResolve(moduleContext, declarationProviderFactory, bindingTrace, platform, targetEnvironment).get<ResolveSession>()
+): ResolveSession = createContainerForLazyResolve(
+        moduleContext, declarationProviderFactory, bindingTrace, platform, targetEnvironment, languageFeatureSettings
+).get<ResolveSession>()

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

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.types.expressions
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
 import org.jetbrains.kotlin.context.withModule
@@ -57,9 +58,9 @@ class LocalClassifierAnalyzer(
         private val typeResolver: TypeResolver,
         private val annotationResolver: AnnotationResolver,
         private val platform: TargetPlatform,
-        private val dynamicTypesSettings: DynamicTypesSettings,
         private val lookupTracker: LookupTracker,
-        private val supertypeLoopChecker: SupertypeLoopChecker
+        private val supertypeLoopChecker: SupertypeLoopChecker,
+        private val languageFeatureSettings: LanguageFeatureSettings
 ) {
     fun processClassOrObject(
             scope: LexicalWritableScope?,
@@ -74,6 +75,7 @@ class LocalClassifierAnalyzer(
                 context.trace,
                 platform,
                 lookupTracker,
+                languageFeatureSettings,
                 LocalClassDescriptorHolder(
                         scope,
                         classOrObject,

compiler/testData/cli/js/jsHelp.out

@@ -10,6 +10,7 @@ where possible options include:
   -main {call,noCall}        Whether a main function should be called; default 'call' (main function will be auto detected)
   -output-prefix <path>      Path to file which will be added to the beginning of output file
   -output-postfix <path>     Path to file which will be added to the end of output file
+  -language-version <version> Provide source compatibility with specified language version
   -nowarn                    Generate no warnings
   -verbose                   Enable verbose logging output
   -version                   Display compiler version

compiler/testData/cli/jvm/help.out

@@ -9,6 +9,7 @@ where possible options include:
   -script                    Evaluate the script file
   -kotlin-home <path>        Path to Kotlin compiler home directory, used for runtime libraries discovery
   -module-name               Module name
+  -language-version <version> Provide source compatibility with specified language version
   -nowarn                    Generate no warnings
   -verbose                   Enable verbose logging output
   -version                   Display compiler version

compiler/testData/cli/jvm/wrongArgument.out

@@ -10,6 +10,7 @@ where possible options include:
   -script                    Evaluate the script file
   -kotlin-home <path>        Path to Kotlin compiler home directory, used for runtime libraries discovery
   -module-name               Module name
+  -language-version <version> Provide source compatibility with specified language version
   -nowarn                    Generate no warnings
   -verbose                   Enable verbose logging output
   -version                   Display compiler version

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

@@ -20,6 +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.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -60,7 +61,8 @@ abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
                 FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
                 CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                 JvmPlatform,
-                targetEnvironment
+                targetEnvironment,
+                LanguageFeatureSettings.LATEST
         )
 
         val resolveSession = container.get<ResolveSession>()

compiler/tests-common/org/jetbrains/kotlin/tests/di/injection.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.tests.di
 
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -33,6 +34,7 @@ fun createContainerForTests(project: Project, module: ModuleDescriptor): Contain
     return ContainerForTests(createContainer("Tests") {
         configureModule(ModuleContext(module, project), JvmPlatform)
         useInstance(LookupTracker.DO_NOTHING)
+        useInstance(LanguageFeatureSettings.LATEST)
         useImpl<ExpressionTypingServices>()
     })
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/serialization/builtins/AdditionalBuiltInsMembersSignatureListsTest.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.serialization.builtins
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.descriptors.resolveClassByFqName
@@ -53,9 +54,10 @@ class AdditionalBuiltInsMembersSignatureListsTest : KotlinTestWithEnvironment()
         val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, emptyList())
 
         val container = createContainerForTopDownAnalyzerForJvm(
-                moduleContext,
+                moduleContext, CliLightClassGenerationSupport.CliBindingTrace(), providerFactory,
-                CliLightClassGenerationSupport.CliBindingTrace(), providerFactory,
+                GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackagePartProvider.EMPTY,
-                GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackagePartProvider.EMPTY)
+                LanguageFeatureSettings.LATEST
+        )
 
         emptyModule.initialize(container.javaDescriptorResolver.packageFragmentProvider)
         emptyModule.setDependencies(emptyModule)

compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -59,7 +60,8 @@ abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
 
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                providerFactory, GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackagePartProvider.EMPTY
+                providerFactory, GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackagePartProvider.EMPTY,
+                LanguageFeatureSettings.LATEST
         )
         moduleContext.initializeModuleContents(container.javaDescriptorResolver.packageFragmentProvider)
 

compiler/tests/org/jetbrains/kotlin/serialization/builtins/AbstractBuiltInsWithJDKMembersTest.kt

@@ -20,6 +20,7 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns.*
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
@@ -61,9 +62,10 @@ abstract class AbstractBuiltInsWithJDKMembersTest : KotlinTestWithEnvironment()
         val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, emptyList())
 
         val container = createContainerForTopDownAnalyzerForJvm(
-                moduleContext,
+                moduleContext, CliLightClassGenerationSupport.CliBindingTrace(), providerFactory,
-                CliLightClassGenerationSupport.CliBindingTrace(), providerFactory,
+                GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackagePartProvider.EMPTY,
-                GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackagePartProvider.EMPTY)
+                LanguageFeatureSettings.LATEST
+        )
 
         emptyModule.initialize(container.javaDescriptorResolver.packageFragmentProvider)
         emptyModule.setDependencies(emptyModule)

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

@@ -21,6 +21,7 @@ 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.LanguageFeatureSettings;
 import org.jetbrains.kotlin.context.ContextKt;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.*;
@@ -109,7 +110,8 @@ public class DefaultModalityModifiersTest extends KotlinTestWithEnvironment {
                     new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(),
                                                             Collections.singleton(aClass.getContainingKtFile())),
                     new BindingTraceContext(),
-                    TargetPlatform.Default.INSTANCE
+                    TargetPlatform.Default.INSTANCE,
+                    LanguageFeatureSettings.LATEST
             );
 
             return (ClassDescriptorWithResolutionScopes) resolveSession.getClassDescriptor(aClass, NoLookupLocation.FROM_TEST);

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

@@ -20,6 +20,7 @@ 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.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
@@ -54,7 +55,10 @@ object JsAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
                 project, moduleContext.storageManager, syntheticFiles, if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope
         )
 
-        val container = createContainerForLazyResolve(moduleContext, declarationProviderFactory, BindingTraceContext(), JsPlatform, targetEnvironment)
+        val container = createContainerForLazyResolve(
+                moduleContext, declarationProviderFactory, BindingTraceContext(), JsPlatform, targetEnvironment,
+                LanguageFeatureSettings.LATEST // TODO: see KT-12410
+        )
         var packageFragmentProvider = container.get<ResolveSession>().packageFragmentProvider
 
         if (moduleInfo is LibraryInfo && KotlinJavaScriptLibraryDetectionUtil.isKotlinJavaScriptLibrary(moduleInfo.library)) {

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

@@ -23,6 +23,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.analyzer.AnalysisResult
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
@@ -170,7 +171,8 @@ private object KotlinResolveDataProvider {
                     resolveSession,
                     trace,
                     targetPlatform,
-                    componentProvider.get<BodyResolveCache>()
+                    componentProvider.get<BodyResolveCache>(),
+                    LanguageFeatureSettings.LATEST // TODO: see KT-12410
             ).get<LazyTopDownAnalyzerForTopLevel>()
 
             lazyTopDownAnalyzer.analyzeDeclarations(

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

@@ -40,6 +40,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns;
 import org.jetbrains.kotlin.codegen.binding.PsiCodegenPredictor;
+import org.jetbrains.kotlin.config.LanguageFeatureSettings;
 import org.jetbrains.kotlin.context.ContextKt;
 import org.jetbrains.kotlin.context.MutableModuleContext;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
@@ -260,7 +261,8 @@ public class SourceNavigationHelper {
                 newModuleContext,
                 providerFactory,
                 new BindingTraceContext(),
-                platform
+                platform,
+                LanguageFeatureSettings.LATEST // TODO: see KT-12410
         );
 
         newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider());

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt

@@ -24,6 +24,7 @@ import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.containers.ContainerUtil
 import org.jetbrains.kotlin.asJava.KotlinCodeBlockModificationListener
 import org.jetbrains.kotlin.cfg.ControlFlowInformationProvider
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.SimpleGlobalContext
 import org.jetbrains.kotlin.context.withModule
@@ -535,7 +536,8 @@ class ResolveElementCache(
                 globalContext.withProject(file.project).withModule(module),
                 trace,
                 targetPlatform,
-                statementFilter
+                statementFilter,
+                LanguageFeatureSettings.LATEST // TODO: see KT-12410
         ).get<BodyResolver>()
     }
 

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.frontend.js.di
 
+import org.jetbrains.kotlin.config.LanguageFeatureSettings
 import org.jetbrains.kotlin.container.createContainer
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
@@ -25,18 +26,17 @@ import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.BodyResolveCache
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
-import org.jetbrains.kotlin.types.DynamicTypesAllowed
 
 fun createTopDownAnalyzerForJs(
         moduleContext: ModuleContext,
         bindingTrace: BindingTrace,
-        declarationProviderFactory: DeclarationProviderFactory
+        declarationProviderFactory: DeclarationProviderFactory,
+        languageFeatureSettings: LanguageFeatureSettings
 ): LazyTopDownAnalyzerForTopLevel {
     val storageComponentContainer = createContainer("TopDownAnalyzerForJs") {
         configureModule(moduleContext, JsPlatform, bindingTrace)
@@ -47,9 +47,9 @@ fun createTopDownAnalyzerForJs(
         CompilerEnvironment.configure(this)
 
         useInstance(LookupTracker.DO_NOTHING)
+        useInstance(languageFeatureSettings)
         useImpl<ResolveSession>()
         useImpl<LazyTopDownAnalyzerForTopLevel>()
     }
     return storageComponentContainer.get<LazyTopDownAnalyzerForTopLevel>()
 }
-

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java

@@ -17,6 +17,8 @@
 package org.jetbrains.kotlin.js.analyze;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.config.CommonConfigurationKeys;
+import org.jetbrains.kotlin.config.LanguageFeatureSettings;
 import org.jetbrains.kotlin.context.ContextKt;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.context.MutableModuleContext;
@@ -72,7 +74,8 @@ public final class TopDownAnalyzerFacadeForJS {
 
         LazyTopDownAnalyzerForTopLevel analyzerForJs = InjectionKt.createTopDownAnalyzerForJs(
                 moduleContext, trace,
-                new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles)
+                new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles),
+                config.getConfiguration().get(CommonConfigurationKeys.LANGUAGE_FEATURE_SETTINGS, LanguageFeatureSettings.LATEST)
         );
         analyzerForJs.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, Collections.<PackageFragmentProvider>emptyList());
         return JsAnalysisResult.success(trace, moduleContext.getModule());