Propagate language version settings into IR type translator

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt

@@ -28,7 +28,9 @@ class JsIntrinsics(
     val context: JsIrBackendContext
 ) {
 
-    private val stubBuilder = DeclarationStubGenerator(module, context.symbolTable, JsLoweredDeclarationOrigin.JS_INTRINSICS_STUB)
+    private val stubBuilder = DeclarationStubGenerator(
+        module, context.symbolTable, JsLoweredDeclarationOrigin.JS_INTRINSICS_STUB, irBuiltIns.languageVersionSettings
+    )
 
     // Equality operations:
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt

@@ -9,6 +9,7 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.common.lower.*
 import org.jetbrains.kotlin.backend.common.runOnFilePostfix
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ir.backend.js.lower.*
 import org.jetbrains.kotlin.ir.backend.js.lower.inline.*
@@ -44,7 +45,7 @@ fun compile(
 
     TopDownAnalyzerFacadeForJS.checkForErrors(files, analysisResult.bindingContext)
 
-    val psi2IrTranslator = Psi2IrTranslator()
+    val psi2IrTranslator = Psi2IrTranslator(configuration.languageVersionSettings)
     val psi2IrContext = psi2IrTranslator.createGeneratorContext(analysisResult.moduleDescriptor, analysisResult.bindingContext)
 
     val moduleFragment = psi2IrTranslator.generateModuleFragment(psi2IrContext, files).removeDuplicates()

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendFacade.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.psi2ir.generators.GeneratorContext
 object JvmBackendFacade {
 
     fun doGenerateFiles(files: Collection<KtFile>, state: GenerationState, errorHandler: CompilationErrorHandler) {
-        val psi2ir = Psi2IrTranslator()
+        val psi2ir = Psi2IrTranslator(state.languageVersionSettings)
         val psi2irContext = psi2ir.createGeneratorContext(state.module, state.bindingContext)
         val irModuleFragment = psi2ir.generateModuleFragment(psi2irContext, files)
 

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt

@@ -30,7 +30,7 @@ object JvmIrCodegenFactory : CodegenFactory {
     override fun generateModule(state: GenerationState, files: Collection<KtFile?>, errorHandler: CompilationErrorHandler) {
         assert(!files.any { it == null })
 
-        val psi2ir = Psi2IrTranslator()
+        val psi2ir = Psi2IrTranslator(state.languageVersionSettings)
         val psi2irContext = psi2ir.createGeneratorContext(state.module, state.bindingContext)
         val irModuleFragment = psi2ir.generateModuleFragment(psi2irContext, files as Collection<KtFile>)
         JvmBackendFacade.doGenerateFilesInternal(state, errorHandler, irModuleFragment, psi2irContext)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/Psi2IrTranslator.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.psi2ir
 
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -29,7 +30,10 @@ import org.jetbrains.kotlin.psi2ir.transformations.insertImplicitCasts
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.utils.SmartList
 
-class Psi2IrTranslator(val configuration: Psi2IrConfiguration = Psi2IrConfiguration()) {
+class Psi2IrTranslator(
+    val languageVersionSettings: LanguageVersionSettings,
+    val configuration: Psi2IrConfiguration = Psi2IrConfiguration()
+) {
     interface PostprocessingStep {
         fun postprocess(context: GeneratorContext, irElement: IrElement)
     }
@@ -46,7 +50,7 @@ class Psi2IrTranslator(val configuration: Psi2IrConfiguration = Psi2IrConfigurat
     }
 
     fun createGeneratorContext(moduleDescriptor: ModuleDescriptor, bindingContext: BindingContext) =
-        GeneratorContext(configuration, moduleDescriptor, bindingContext)
+        GeneratorContext(configuration, moduleDescriptor, bindingContext, languageVersionSettings)
 
     fun generateModuleFragment(context: GeneratorContext, ktFiles: Collection<KtFile>): IrModuleFragment {
         val moduleGenerator = ModuleGenerator(context)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/GeneratorContext.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.psi2ir.generators
 
 import org.jetbrains.kotlin.builtins.ReflectionTypes
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.NotFoundClasses
 import org.jetbrains.kotlin.ir.builders.IrGeneratorContext
@@ -33,11 +34,12 @@ class GeneratorContext(
     val configuration: Psi2IrConfiguration,
     val moduleDescriptor: ModuleDescriptor,
     val bindingContext: BindingContext,
+    val languageVersionSettings: LanguageVersionSettings,
     val symbolTable: SymbolTable = SymbolTable()
 ) : IrGeneratorContext() {
 
     val constantValueGenerator: ConstantValueGenerator = ConstantValueGenerator(moduleDescriptor, symbolTable)
-    val typeTranslator: TypeTranslator = TypeTranslator(symbolTable)
+    val typeTranslator: TypeTranslator = TypeTranslator(symbolTable, languageVersionSettings)
 
     init {
         typeTranslator.constantValueGenerator = constantValueGenerator

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt

@@ -32,6 +32,7 @@ class IrBuiltIns(
     private val typeTranslator: TypeTranslator,
     outerSymbolTable: SymbolTable? = null
 ) {
+    val languageVersionSettings = typeTranslator.languageVersionSettings
 
     private val builtInsModule = builtIns.builtInsModule
 
@@ -39,7 +40,8 @@ class IrBuiltIns(
     val irBuiltInsExternalPackageFragment = IrExternalPackageFragmentImpl(IrExternalPackageFragmentSymbolImpl(packageFragment))
 
     private val symbolTable = outerSymbolTable ?: SymbolTable()
-    private val stubBuilder = DeclarationStubGenerator(builtInsModule, symbolTable, IrDeclarationOrigin.IR_BUILTINS_STUB)
+    private val stubBuilder =
+        DeclarationStubGenerator(builtInsModule, symbolTable, IrDeclarationOrigin.IR_BUILTINS_STUB, languageVersionSettings)
 
     private fun ClassDescriptor.toIrSymbol() = symbolTable.referenceClass(this)
     private fun KotlinType.toIrType() = typeTranslator.translateType(this)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.ir.util
 
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
@@ -34,9 +35,10 @@ import org.jetbrains.kotlin.types.KotlinType
 class DeclarationStubGenerator(
     moduleDescriptor: ModuleDescriptor,
     val symbolTable: SymbolTable,
-    val origin: IrDeclarationOrigin
+    val origin: IrDeclarationOrigin,
+    val languageVersionSettings: LanguageVersionSettings
 ) {
-    private val typeTranslator = TypeTranslator(symbolTable)
+    private val typeTranslator = TypeTranslator(symbolTable, languageVersionSettings)
     private val constantValueGenerator = ConstantValueGenerator(moduleDescriptor, symbolTable)
 
     init {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExternalDependenciesGenerator.kt

@@ -29,7 +29,9 @@ class ExternalDependenciesGenerator(
     val symbolTable: SymbolTable,
     val irBuiltIns: IrBuiltIns
 ) {
-    private val stubGenerator = DeclarationStubGenerator(moduleDescriptor, symbolTable, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB)
+    private val stubGenerator = DeclarationStubGenerator(
+        moduleDescriptor, symbolTable, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, irBuiltIns.languageVersionSettings
+    )
 
     fun generateUnboundSymbolsAsDependencies(irModule: IrModuleFragment) {
         DependencyGenerationTask(irModule).run()

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt

@@ -5,6 +5,8 @@
 
 package org.jetbrains.kotlin.ir.util
 
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
@@ -20,7 +22,8 @@ import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typesApproximation.approximateCapturedTypes
 
 class TypeTranslator(
-    private val symbolTable: SymbolTable
+    private val symbolTable: SymbolTable,
+    val languageVersionSettings: LanguageVersionSettings
 ) {
 
     private val typeParametersResolver = ScopedTypeParametersResolver()
@@ -50,7 +53,7 @@ class TypeTranslator(
 
     private fun translateType(ktType0: KotlinType, variance: Variance): IrTypeProjection {
         // TODO "old" JVM BE does this for reified type arguments. Is it ok for arbitrary subexpressions?
-        
+
         val ktTypeUpper =
             if (ktType0.constructor.isDenotable)
                 ktType0

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt

@@ -85,6 +85,8 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
         val modules = createModules(groupedByModule, context.storageManager)
         val moduleBindings = HashMap<TestModule?, BindingContext>()
 
+        val languageVersionSettingsByModule = HashMap<TestModule?, LanguageVersionSettings>()
+
         for ((testModule, testFilesInModule) in groupedByModule) {
             val ktFiles = getKtFiles(testFilesInModule, true)
 
@@ -98,6 +100,9 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
                         if (coroutinesPackage.contains("experimental")) LanguageVersion.KOTLIN_1_2 else LanguageVersion.KOTLIN_1_3
                     )
                 else loadLanguageVersionSettings(testFilesInModule)
+
+            languageVersionSettingsByModule[testModule] = languageVersionSettings
+
             val moduleContext = context.withProject(project).withModule(oldModule)
 
             val separateModules = groupedByModule.size == 1 && groupedByModule.keys.single() == null
@@ -184,7 +189,9 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
         exceptionFromLazyResolveLogValidation?.let { throw it }
         exceptionFromDynamicCallDescriptorsValidation?.let { throw it }
 
-        performAdditionalChecksAfterDiagnostics(testDataFile, files, groupedByModule, modules, moduleBindings)
+        performAdditionalChecksAfterDiagnostics(
+            testDataFile, files, groupedByModule, modules, moduleBindings, languageVersionSettingsByModule
+        )
     }
 
     protected open fun getExpectedDiagnosticsFile(testDataFile: File): File {
@@ -212,7 +219,8 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
         testFiles: List<TestFile>,
         moduleFiles: Map<TestModule?, List<TestFile>>,
         moduleDescriptors: Map<TestModule?, ModuleDescriptorImpl>,
-        moduleBindings: Map<TestModule?, BindingContext>
+        moduleBindings: Map<TestModule?, BindingContext>,
+        languageVersionSettingsByModule: Map<TestModule?, LanguageVersionSettings>
     ) {
         // To be overridden by diagnostic-like tests.
     }

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt

@@ -108,6 +108,8 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava<TestModule, Tes
     }
 
     class TestModule(val name: String) : Comparable<TestModule> {
+        lateinit var languageVersionSettings: LanguageVersionSettings
+
         private val dependencies = ArrayList<TestModule>()
 
         fun getDependencies(): MutableList<TestModule> = dependencies

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt

@@ -20,6 +20,8 @@ import junit.framework.TestCase
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.CodegenTestCase
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -88,7 +90,12 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
     protected fun generateIrModule(ignoreErrors: Boolean = false, shouldGenerate: (KtFile) -> Boolean = { true }): IrModuleFragment {
         assert(myFiles != null) { "myFiles not initialized" }
         assert(myEnvironment != null) { "myEnvironment not initialized" }
-        return generateIrModule(myFiles.psiFiles, myEnvironment, Psi2IrTranslator(Psi2IrConfiguration(ignoreErrors)), shouldGenerate)
+        return generateIrModule(
+            myFiles.psiFiles,
+            myEnvironment,
+            Psi2IrTranslator(myEnvironment.configuration.languageVersionSettings, Psi2IrConfiguration(ignoreErrors)),
+            shouldGenerate
+        )
     }
 
     protected fun generateIrFilesAsSingleModule(testFiles: List<TestFile>, ignoreErrors: Boolean = false): Map<TestFile, IrFile> {
@@ -133,9 +140,12 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() {
             ktFiles: List<KtFile>,
             moduleDescriptor: ModuleDescriptor,
             bindingContext: BindingContext,
+            languageVersionSettings: LanguageVersionSettings,
             ignoreErrors: Boolean = false
         ) =
-            generateIrModule(ktFiles, moduleDescriptor, bindingContext, Psi2IrTranslator(Psi2IrConfiguration(ignoreErrors)))
+            generateIrModule(
+                ktFiles, moduleDescriptor, bindingContext, Psi2IrTranslator(languageVersionSettings, Psi2IrConfiguration(ignoreErrors))
+            )
 
         fun generateIrModule(
             ktFiles: List<KtFile>,

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractPsi2IrDiagnosticsTest.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.ir
 
 import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.ir.util.dump
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -29,14 +30,18 @@ abstract class AbstractPsi2IrDiagnosticsTest : AbstractDiagnosticsTest() {
         testFiles: List<TestFile>,
         moduleFiles: Map<TestModule?, List<TestFile>>,
         moduleDescriptors: Map<TestModule?, ModuleDescriptorImpl>,
-        moduleBindings: Map<TestModule?, BindingContext>
+        moduleBindings: Map<TestModule?, BindingContext>,
+        languageVersionSettingsByModule: Map<TestModule?, LanguageVersionSettings>
     ) {
         val actualIrDump = StringBuilder()
         for (module in moduleFiles.keys) {
             val ktFiles = moduleFiles[module]?.mapNotNull { it.ktFile } ?: continue
             val moduleDescriptor = moduleDescriptors[module] ?: continue
             val moduleBindingContext = moduleBindings[module] ?: continue
-            val irModule = AbstractIrGeneratorTestCase.generateIrModule(ktFiles, moduleDescriptor, moduleBindingContext, true)
+            val languageVersionSettings = languageVersionSettingsByModule[module] ?: continue
+            val irModule = AbstractIrGeneratorTestCase.generateIrModule(
+                ktFiles, moduleDescriptor, moduleBindingContext, languageVersionSettings, true
+            )
             actualIrDump.append(irModule.dump())
         }