Refactor LanguageFeatureSettings: Add LanguageVersion and LanguageFeature entities

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

@@ -22,6 +22,7 @@ import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.SystemInfo;
 import com.sampullara.cli.Args;
 import kotlin.Pair;
+import kotlin.collections.ArraysKt;
 import kotlin.collections.CollectionsKt;
 import kotlin.jvm.functions.Function1;
 import org.fusesource.jansi.AnsiConsole;
@@ -34,7 +35,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.LanguageVersion;
 import org.jetbrains.kotlin.config.Services;
 import org.jetbrains.kotlin.progress.CompilationCanceledException;
 import org.jetbrains.kotlin.progress.CompilationCanceledStatus;
@@ -246,14 +247,19 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> {
         }
 
         if (arguments.languageVersion != null) {
-            LanguageFeatureSettings languageFeatureSettings = LanguageFeatureSettings.fromLanguageVersion(arguments.languageVersion);
+            LanguageVersion languageFeatureSettings = LanguageVersion.fromVersionString(arguments.languageVersion);
             if (languageFeatureSettings != null) {
                 configuration.put(CommonConfigurationKeys.LANGUAGE_FEATURE_SETTINGS, languageFeatureSettings);
             }
             else {
-                String message =
-                        "Unknown language version: " + arguments.languageVersion + "\n" +
-                        "Supported language versions: " + StringsKt.join(LanguageFeatureSettings.getAllLanguageVersions(), ", ");
+                List<String> versionStrings = ArraysKt.map(LanguageVersion.values(), new Function1<LanguageVersion, String>() {
+                    @Override
+                    public String invoke(LanguageVersion version) {
+                        return version.getVersionString();
+                    }
+                });
+                String message = "Unknown language version: " + arguments.languageVersion + "\n" +
+                                 "Supported language versions: " + StringsKt.join(versionStrings, ", ");
                 configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).report(
                         CompilerMessageSeverity.ERROR, message, CompilerMessageLocation.NO_LOCATION
                 );

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

@@ -17,7 +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.config.LanguageVersion
 import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
@@ -44,7 +44,7 @@ fun createContainerForReplWithJava(
 ): ContainerForReplWithJava = createContainer("ReplWithJava") {
     useInstance(packagePartProvider)
     configureModule(moduleContext, JvmPlatform, bindingTrace)
-    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING, LanguageFeatureSettings.LATEST)
+    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING, LanguageVersion.LATEST)
 
     useInstance(declarationProviderFactory)
 

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

@@ -20,7 +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.config.LanguageVersion
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
@@ -91,7 +91,7 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
                 moduleClassResolver,
                 targetEnvironment,
                 packagePartProvider,
-                LanguageFeatureSettings.LATEST // TODO: see KT-12410
+                LanguageVersion.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,7 +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.config.LanguageVersion;
 import org.jetbrains.kotlin.context.ContextKt;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.context.MutableModuleContext;
@@ -102,7 +102,7 @@ public enum TopDownAnalyzerFacadeForJVM {
                 GlobalSearchScope.allScope(project),
                 lookupTracker,
                 packagePartProvider,
-                configuration.get(CommonConfigurationKeys.LANGUAGE_FEATURE_SETTINGS, LanguageFeatureSettings.LATEST)
+                configuration.get(CommonConfigurationKeys.LANGUAGE_FEATURE_SETTINGS, LanguageVersion.LATEST)
         );
 
         List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();

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

@@ -16,31 +16,38 @@
 
 package org.jetbrains.kotlin.config
 
-// Note: names of these parameters are also used in diagnostic tests
-class LanguageFeatureSettings(
-        val typeAliases: Boolean = true,
-        val localDelegatedProperties: Boolean = true,
-        val topLevelSealedInheritance: Boolean = true
-) {
+import org.jetbrains.kotlin.config.LanguageVersion.KOTLIN_1_1
+
+
+enum class LanguageFeature(val sinceVersion: LanguageVersion) {
+    // Note: names of these entries are also used in diagnostic tests
+    TypeAliases(KOTLIN_1_1),
+    LocalDelegatedProperties(KOTLIN_1_1),
+    TopLevelSealedInheritance(KOTLIN_1_1);
+
     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]
-
-        @JvmStatic
-        fun getAllLanguageVersions(): List<String> = SETTINGS.keys.toList()
+        fun fromString(str: String) = values().find { it.name == str }
     }
 }
+
+enum class LanguageVersion(val versionString: String): LanguageFeatureSettings {
+    KOTLIN_1_0("1.0"),
+    KOTLIN_1_1("1.1");
+
+    override fun supportsFeature(feature: LanguageFeature): Boolean {
+        return this.ordinal >= feature.sinceVersion.ordinal
+    }
+
+    companion object {
+        @JvmStatic
+        fun fromVersionString(str: String) = values().find { it.versionString == str }
+
+        @JvmField
+        val LATEST = values().last()
+    }
+}
+
+interface LanguageFeatureSettings {
+    fun supportsFeature(feature: LanguageFeature): Boolean
+}

compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java

@@ -51,6 +51,7 @@ import org.jetbrains.kotlin.util.slicedMap.WritableSlice;
 
 import java.util.*;
 
+import static org.jetbrains.kotlin.config.LanguageFeature.TopLevelSealedInheritance;
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
@@ -398,7 +399,7 @@ public class BodyResolver {
         if (ktClassOrObject instanceof KtEnumEntry) {
             parentEnumOrSealed = Collections.singleton(((ClassDescriptor) descriptor.getContainingDeclaration()).getTypeConstructor());
         }
-        else if (languageFeatureSettings.getTopLevelSealedInheritance() && DescriptorUtils.isTopLevelDeclaration(descriptor)) {
+        else if (languageFeatureSettings.supportsFeature(TopLevelSealedInheritance) && DescriptorUtils.isTopLevelDeclaration(descriptor)) {
             // TODO: improve diagnostic when top level sealed inheritance is disabled
             for (KotlinType supertype : supertypes.values()) {
                 ClassifierDescriptor classifierDescriptor = supertype.getConstructor().getDeclarationDescriptor();

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.LanguageFeatureSettings
+import org.jetbrains.kotlin.config.LanguageVersion
 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,
-                LanguageFeatureSettings.LATEST
+                LanguageVersion.LATEST
         )
 
         val resolveSession = container.get<ResolveSession>()

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

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.tests.di
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.config.LanguageFeatureSettings
+import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -34,7 +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)
+        useInstance(LanguageVersion.LATEST)
         useImpl<ExpressionTypingServices>()
     })
 }

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

@@ -19,7 +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.config.LanguageVersion
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.descriptors.resolveClassByFqName
@@ -56,7 +56,7 @@ class AdditionalBuiltInsMembersSignatureListsTest : KotlinTestWithEnvironment()
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext, CliLightClassGenerationSupport.CliBindingTrace(), providerFactory,
                 GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackagePartProvider.EMPTY,
-                LanguageFeatureSettings.LATEST
+                LanguageVersion.LATEST
         )
 
         emptyModule.initialize(container.javaDescriptorResolver.packageFragmentProvider)

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

@@ -22,6 +22,7 @@ import com.intellij.lang.java.JavaLanguage;
 import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.util.Conditions;
 import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiFileFactory;
 import com.intellij.psi.search.GlobalSearchScope;
@@ -30,16 +31,13 @@ import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.HashMap;
 import kotlin.collections.CollectionsKt;
-import kotlin.jvm.JvmClassMappingKt;
 import kotlin.jvm.functions.Function1;
-import kotlin.reflect.KClass;
-import kotlin.reflect.KClasses;
-import kotlin.reflect.KFunction;
-import kotlin.reflect.KParameter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.asJava.DuplicateJvmSignatureUtilKt;
+import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.config.LanguageFeatureSettings;
+import org.jetbrains.kotlin.config.LanguageVersion;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.diagnostics.*;
 import org.jetbrains.kotlin.load.java.InternalFlexibleTypeTransformer;
@@ -95,26 +93,6 @@ public abstract class BaseDiagnosticsTest
 
     public static final String MARK_DYNAMIC_CALLS_DIRECTIVE = "MARK_DYNAMIC_CALLS";
 
-    private static final KFunction<LanguageFeatureSettings> LANGUAGE_FEATURE_SETTINGS_CONSTRUCTOR;
-    private static final Map<String, KParameter> LANGUAGE_FEATURE_SETTINGS_PARAMETERS;
-
-    static {
-        KClass<LanguageFeatureSettings> kotlinClass = JvmClassMappingKt.getKotlinClass(LanguageFeatureSettings.class);
-        LANGUAGE_FEATURE_SETTINGS_CONSTRUCTOR = KClasses.getPrimaryConstructor(kotlinClass);
-        assert LANGUAGE_FEATURE_SETTINGS_CONSTRUCTOR != null
-                : "LanguageFeatureSettings should have a primary constructor: " + kotlinClass.getConstructors();
-
-        LANGUAGE_FEATURE_SETTINGS_PARAMETERS = CollectionsKt.associateBy(
-                LANGUAGE_FEATURE_SETTINGS_CONSTRUCTOR.getParameters(),
-                new Function1<KParameter, String>() {
-                    @Override
-                    public String invoke(KParameter parameter) {
-                        return parameter.getName();
-                    }
-                }
-        );
-    }
-
     @Override
     protected TestModule createTestModule(@NotNull String name) {
         return new TestModule(name);
@@ -187,30 +165,39 @@ public abstract class BaseDiagnosticsTest
             Assert.fail(
                     "Wrong syntax in the '// !LANGUAGE: ...' directive:\n" +
                     "found: '" + directives + "'\n" +
-                    "Must be '([+-]languageFeatureName)+'\n" +
+                    "Must be '([+-]LanguageFeatureName)+'\n" +
                     "where '+' means 'enable' and '-' means 'disable'\n" +
-                    "and language feature names are names of parameters of the class LanguageFeatureSettings"
+                    "and language feature names are names of enum entries in LanguageFeature enum class"
             );
         }
 
-        Map<KParameter, Boolean> values = new HashMap<KParameter, Boolean>();
+        final Map<LanguageFeature, Boolean> values = new HashMap<LanguageFeature, Boolean>();
         do {
             boolean enable = matcher.group(1).equals("+");
             String name = matcher.group(2);
-            KParameter parameter = LANGUAGE_FEATURE_SETTINGS_PARAMETERS.get(name);
-            if (parameter == null) {
+            LanguageFeature feature = LanguageFeature.fromString(StringUtil.capitalize(name));
+            if (feature == null) {
                 Assert.fail(
                         "Language feature not found, please check spelling: " + name + "\n" +
-                        "Known features:\n    " + StringsKt.join(LANGUAGE_FEATURE_SETTINGS_PARAMETERS.keySet(), "\n    ")
+                        "Known features:\n    " + StringsKt.join(Arrays.asList(LanguageFeature.values()), "\n    ")
                 );
             }
-            if (values.put(parameter, enable) != null) {
+            if (values.put(feature, enable) != null) {
                 Assert.fail("Duplicate entry for the language feature: " + name);
             }
         }
         while (matcher.find());
 
-        return LANGUAGE_FEATURE_SETTINGS_CONSTRUCTOR.callBy(values);
+        return new LanguageFeatureSettings() {
+            @Override
+            public boolean supportsFeature(@NotNull LanguageFeature feature) {
+                Boolean enabled = values.get(feature);
+                if (enabled != null) {
+                    return enabled;
+                }
+                return LanguageVersion.LATEST.supportsFeature(feature);
+            }
+        };
     }
 
     public static Condition<Diagnostic> parseDiagnosticFilterDirective(Map<String, String> directiveMap) {

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

@@ -21,7 +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.config.LanguageVersion
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -61,7 +61,7 @@ abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                 providerFactory, GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackagePartProvider.EMPTY,
-                LanguageFeatureSettings.LATEST
+                LanguageVersion.LATEST
         )
         moduleContext.initializeModuleContents(container.javaDescriptorResolver.packageFragmentProvider)
 

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

@@ -20,7 +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.config.LanguageVersion
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
@@ -64,7 +64,7 @@ abstract class AbstractBuiltInsWithJDKMembersTest : KotlinTestWithEnvironment()
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext, CliLightClassGenerationSupport.CliBindingTrace(), providerFactory,
                 GlobalSearchScope.allScope(environment.project), LookupTracker.DO_NOTHING, PackagePartProvider.EMPTY,
-                LanguageFeatureSettings.LATEST
+                LanguageVersion.LATEST
         )
 
         emptyModule.initialize(container.javaDescriptorResolver.packageFragmentProvider)

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

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

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

@@ -20,7 +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.config.LanguageVersion
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
@@ -57,7 +57,7 @@ object JsAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
 
         val container = createContainerForLazyResolve(
                 moduleContext, declarationProviderFactory, BindingTraceContext(), JsPlatform, targetEnvironment,
-                LanguageFeatureSettings.LATEST // TODO: see KT-12410
+                LanguageVersion.LATEST // TODO: see KT-12410
         )
         var packageFragmentProvider = container.get<ResolveSession>().packageFragmentProvider
 

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

@@ -23,7 +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.config.LanguageVersion
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
@@ -172,7 +172,7 @@ private object KotlinResolveDataProvider {
                     trace,
                     targetPlatform,
                     componentProvider.get<BodyResolveCache>(),
-                    LanguageFeatureSettings.LATEST // TODO: see KT-12410
+                    LanguageVersion.LATEST // TODO: see KT-12410
             ).get<LazyTopDownAnalyzerForTopLevel>()
 
             lazyTopDownAnalyzer.analyzeDeclarations(

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

@@ -40,7 +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.config.LanguageVersion;
 import org.jetbrains.kotlin.context.ContextKt;
 import org.jetbrains.kotlin.context.MutableModuleContext;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
@@ -262,7 +262,7 @@ public class SourceNavigationHelper {
                 providerFactory,
                 new BindingTraceContext(),
                 platform,
-                LanguageFeatureSettings.LATEST // TODO: see KT-12410
+                LanguageVersion.LATEST // TODO: see KT-12410
         );
 
         newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider());

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

@@ -24,7 +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.config.LanguageVersion
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.SimpleGlobalContext
 import org.jetbrains.kotlin.context.withModule
@@ -537,7 +537,7 @@ class ResolveElementCache(
                 trace,
                 targetPlatform,
                 statementFilter,
-                LanguageFeatureSettings.LATEST // TODO: see KT-12410
+                LanguageVersion.LATEST // TODO: see KT-12410
         ).get<BodyResolver>()
     }
 

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

@@ -18,7 +18,7 @@ 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.config.LanguageVersion;
 import org.jetbrains.kotlin.context.ContextKt;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.context.MutableModuleContext;
@@ -75,7 +75,7 @@ public final class TopDownAnalyzerFacadeForJS {
         LazyTopDownAnalyzerForTopLevel analyzerForJs = InjectionKt.createTopDownAnalyzerForJs(
                 moduleContext, trace,
                 new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles),
-                config.getConfiguration().get(CommonConfigurationKeys.LANGUAGE_FEATURE_SETTINGS, LanguageFeatureSettings.LATEST)
+                config.getConfiguration().get(CommonConfigurationKeys.LANGUAGE_FEATURE_SETTINGS, LanguageVersion.LATEST)
         );
         analyzerForJs.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, Collections.<PackageFragmentProvider>emptyList());
         return JsAnalysisResult.success(trace, moduleContext.getModule());