IR: add BackendContext.typeSystem and JvmIrTypeSystemContext

To be able to override JVM-specific behavior of IrTypeSystemContext in
JVM IR, for things like JVM flexible types.

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/BackendContext.kt

@@ -19,15 +19,16 @@ package org.jetbrains.kotlin.backend.common
 import org.jetbrains.kotlin.backend.common.ir.Ir
 import org.jetbrains.kotlin.backend.common.ir.SharedVariablesManager
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
 import org.jetbrains.kotlin.name.FqName
 
 interface BackendContext {
     val ir: Ir<CommonBackendContext>
     val builtIns: KotlinBuiltIns
     val irBuiltIns: IrBuiltIns
+    val typeSystem: IrTypeSystemContext
     val sharedVariablesManager: SharedVariablesManager
     val internalPackageFqn: FqName
     val irFactory: IrFactory

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt

@@ -479,8 +479,8 @@ private class FakeOverrideBuilderForLowerings : FakeOverrideBuilderStrategy() {
     }
 }
 
-fun IrClass.addFakeOverrides(irBuiltIns: IrBuiltIns, implementedMembers: List<IrOverridableMember> = emptyList()) {
-    IrOverridingUtil(irBuiltIns, FakeOverrideBuilderForLowerings())
+fun IrClass.addFakeOverrides(typeSystem: IrTypeSystemContext, implementedMembers: List<IrOverridableMember> = emptyList()) {
+    IrOverridingUtil(typeSystem, FakeOverrideBuilderForLowerings())
         .buildFakeOverridesForClassUsingOverriddenSymbols(this, implementedMembers, compatibilityMode = false)
         .forEach { addChild(it) }
 }

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractSuspendFunctionsLowering.kt

@@ -407,7 +407,7 @@ abstract class AbstractSuspendFunctionsLowering<C : CommonBackendContext>(val co
             }
 
             coroutineClass.superTypes += superTypes
-            coroutineClass.addFakeOverrides(context.irBuiltIns)
+            coroutineClass.addFakeOverrides(context.typeSystem)
 
             initializeStateMachine(coroutineConstructors, coroutineClassThis)
 

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SingleAbstractMethodLowering.kt

@@ -13,9 +13,9 @@ import org.jetbrains.kotlin.backend.common.ir.addFakeOverrides
 import org.jetbrains.kotlin.backend.common.ir.copyTo
 import org.jetbrains.kotlin.backend.common.ir.createImplicitParameterDeclarationWithWrappedDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.DescriptorVisibility
+import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.builders.*
@@ -32,7 +32,6 @@ import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.util.OperatorNameConventions
-import org.jetbrains.kotlin.ir.util.functions
 
 abstract class SingleAbstractMethodLowering(val context: CommonBackendContext) : FileLoweringPass, IrElementTransformerVoidWithContext() {
     // SAM wrappers are cached, either in the file class (if it exists), or in a top-level enclosing class.
@@ -234,7 +233,7 @@ abstract class SingleAbstractMethodLowering(val context: CommonBackendContext) :
         if (superType.needEqualsHashCodeMethods)
             generateEqualsHashCode(subclass, superType, field)
 
-        subclass.addFakeOverrides(context.irBuiltIns)
+        subclass.addFakeOverrides(context.typeSystem)
 
         return subclass
     }

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/ForLoopsLowering.kt

@@ -12,7 +12,10 @@ import org.jetbrains.kotlin.backend.common.lower.createIrBuilder
 import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
-import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.IrDeclaration
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
+import org.jetbrains.kotlin.ir.declarations.IrVariable
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
 import org.jetbrains.kotlin.ir.util.dump
@@ -236,7 +239,7 @@ private class RangeLoopTransformer(
                 mainLoopVariable.endOffset,
                 context.irBuiltIns.unitType,
                 IrStatementOrigin.FOR_LOOP_NEXT,
-                loopHeader.initializeIteration(mainLoopVariable, loopVariableComponents, this)
+                loopHeader.initializeIteration(mainLoopVariable, loopVariableComponents, this, this@RangeLoopTransformer.context)
             )
         }
 

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/loops/HeaderProcessor.kt

@@ -48,7 +48,8 @@ internal interface ForLoopHeader {
     fun initializeIteration(
         loopVariable: IrVariable?,
         loopVariableComponents: Map<Int, IrVariable>,
-        builder: DeclarationIrBuilder
+        builder: DeclarationIrBuilder,
+        backendContext: CommonBackendContext,
     ): List<IrStatement>
 
     /** Builds a new loop from the old loop. */
@@ -273,8 +274,9 @@ internal class ProgressionLoopHeader(
     override fun initializeIteration(
         loopVariable: IrVariable?,
         loopVariableComponents: Map<Int, IrVariable>,
-        builder: DeclarationIrBuilder
-    ) =
+        builder: DeclarationIrBuilder,
+        backendContext: CommonBackendContext,
+    ): List<IrStatement> =
         with(builder) {
             // loopVariable is used in the loop condition if it can overflow. If no loopVariable was provided, create one.
             this@ProgressionLoopHeader.loopVariable = if (headerInfo.canOverflow && loopVariable == null) {
@@ -377,8 +379,9 @@ internal class IndexedGetLoopHeader(
     override fun initializeIteration(
         loopVariable: IrVariable?,
         loopVariableComponents: Map<Int, IrVariable>,
-        builder: DeclarationIrBuilder
-    ) =
+        builder: DeclarationIrBuilder,
+        backendContext: CommonBackendContext,
+    ): List<IrStatement> =
         with(builder) {
             // loopVariable = objectVariable[inductionVariable]
             val indexedGetFun = with(headerInfo.expressionHandler) { headerInfo.objectVariable.type.getFunction }
@@ -483,8 +486,9 @@ internal class WithIndexLoopHeader(
     override fun initializeIteration(
         loopVariable: IrVariable?,
         loopVariableComponents: Map<Int, IrVariable>,
-        builder: DeclarationIrBuilder
-    ) =
+        builder: DeclarationIrBuilder,
+        backendContext: CommonBackendContext,
+    ): List<IrStatement> =
         with(builder) {
             // The `withIndex()` extension function returns a lazy Iterable that wraps each element of the underlying iterable (e.g., array,
             // progression, Iterable, Sequence, CharSequence) into an IndexedValue containing the index of that element and the element
@@ -553,7 +557,7 @@ internal class WithIndexLoopHeader(
             // We "wire" the 1st destructured component to index, and the 2nd to the loop variable value from the underlying iterable.
             loopVariableComponents[1]?.initializer = irGet(indexVariable)
             listOfNotNull(loopVariableComponents[1], incrementIndexStatement) +
-                    nestedLoopHeader.initializeIteration(loopVariableComponents[2], linkedMapOf(), builder)
+                    nestedLoopHeader.initializeIteration(loopVariableComponents[2], linkedMapOf(), builder, backendContext)
         }
 
     // Use the nested loop header to build the loop. More info in comments in initializeIteration().
@@ -571,7 +575,8 @@ internal class IterableLoopHeader(
     override fun initializeIteration(
         loopVariable: IrVariable?,
         loopVariableComponents: Map<Int, IrVariable>,
-        builder: DeclarationIrBuilder
+        builder: DeclarationIrBuilder,
+        backendContext: CommonBackendContext,
     ): List<IrStatement> =
         with(builder) {
             // loopVariable = iteratorVar.next()
@@ -586,7 +591,7 @@ internal class IterableLoopHeader(
             // Find and replace the call to preserve any type-casts.
             loopVariable?.initializer = loopVariable?.initializer?.transform(InitializerCallReplacer(next), null)
             // Even if there is no loop variable, we always want to call `next()` for iterables and sequences.
-            listOf(loopVariable ?: next.coerceToUnitIfNeeded(next.type, context.irBuiltIns))
+            listOf(loopVariable ?: next.coerceToUnitIfNeeded(next.type, context.irBuiltIns, backendContext.typeSystem))
         }
 
     override fun buildLoop(builder: DeclarationIrBuilder, oldLoop: IrLoop, newBody: IrExpression?): LoopReplacement = with(builder) {