Replace JvmTarget with GenerationState in DescriptorBasedFunctionHandleForJvm

compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java

@@ -1057,14 +1057,14 @@ public class FunctionCodegen {
     private boolean hasSpecialBridgeMethod(@NotNull FunctionDescriptor descriptor) {
         if (SpecialBuiltinMembers.getOverriddenBuiltinReflectingJvmDescriptor(descriptor) == null) return false;
         return !BuiltinSpecialBridgesUtil.generateBridgesForBuiltinSpecial(
-                descriptor, typeMapper::mapAsmMethod, state.getTarget()
+                descriptor, typeMapper::mapAsmMethod, state
         ).isEmpty();
     }
 
     public void generateBridges(@NotNull FunctionDescriptor descriptor) {
         if (descriptor instanceof ConstructorDescriptor) return;
         if (owner.getContextKind() == OwnerKind.DEFAULT_IMPLS) return;
-        if (JvmBridgesImplKt.isAbstractOnJvmIgnoringActualModality(state.getTarget(), descriptor)) return;
+        if (JvmBridgesImplKt.isAbstractOnJvmIgnoringActualModality(state, descriptor)) return;
 
         // equals(Any?), hashCode(), toString() never need bridges
         if (isMethodOfAny(descriptor)) return;
@@ -1074,7 +1074,7 @@ public class FunctionCodegen {
         Set<Bridge<Method>> bridgesToGenerate;
         if (!isSpecial) {
             bridgesToGenerate =
-                    JvmBridgesImplKt.generateBridgesForFunctionDescriptorForJvm(descriptor, typeMapper::mapAsmMethod, state.getTarget());
+                    JvmBridgesImplKt.generateBridgesForFunctionDescriptorForJvm(descriptor, typeMapper::mapAsmMethod, state);
             if (!bridgesToGenerate.isEmpty()) {
                 PsiElement origin = descriptor.getKind() == DECLARATION ? getSourceFromDescriptor(descriptor) : null;
                 boolean isSpecialBridge =
@@ -1087,7 +1087,7 @@ public class FunctionCodegen {
         }
         else {
             Set<BridgeForBuiltinSpecial<Method>> specials = BuiltinSpecialBridgesUtil.generateBridgesForBuiltinSpecial(
-                    descriptor, typeMapper::mapAsmMethod, state.getTarget()
+                    descriptor, typeMapper::mapAsmMethod, state
             );
 
             if (!specials.isEmpty()) {

compiler/backend/src/org/jetbrains/kotlin/codegen/JvmBridgesImpl.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.backend.common.bridges.*
+import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
@@ -15,10 +16,10 @@ import org.jetbrains.kotlin.resolve.jvm.annotations.hasPlatformDependentAnnotati
 
 class DescriptorBasedFunctionHandleForJvm(
     descriptor: FunctionDescriptor,
-    private val jvmTarget: JvmTarget
+    private val state: GenerationState
 ) : DescriptorBasedFunctionHandle(descriptor) {
     override fun createHandleForOverridden(overridden: FunctionDescriptor) =
-        DescriptorBasedFunctionHandleForJvm(overridden, jvmTarget)
+        DescriptorBasedFunctionHandleForJvm(overridden, state)
 
     /*
         For @JvmDefault JVM members they are placed in interface classes and
@@ -26,7 +27,7 @@ class DescriptorBasedFunctionHandleForJvm(
         For non-@JvmDefault interfaces function, its body is generated in a separate place (DefaultImpls) and
         the method in the interface is abstract so we must not generate bridges for such cases.
     */
-    override val isAbstract: Boolean = super.isAbstract || isAbstractOnJvmIgnoringActualModality(jvmTarget, descriptor)
+    override val isAbstract: Boolean = super.isAbstract || isAbstractOnJvmIgnoringActualModality(state, descriptor)
 
     override val mayBeUsedAsSuperImplementation: Boolean =
         super.mayBeUsedAsSuperImplementation || descriptor.isJvmDefaultOrPlatformDependent()
@@ -48,9 +49,9 @@ private fun needToGenerateDelegationToDefaultImpls(descriptor: FunctionDescripto
 /**
  * @return return true for interface method not annotated with @JvmDefault or @PlatformDependent
  */
-fun isAbstractOnJvmIgnoringActualModality(jvmTarget: JvmTarget, descriptor: FunctionDescriptor): Boolean {
+fun isAbstractOnJvmIgnoringActualModality(state: GenerationState, descriptor: FunctionDescriptor): Boolean {
     if (!DescriptorUtils.isInterface(descriptor.containingDeclaration)) return false
-    if (jvmTarget == JvmTarget.JVM_1_6) return true
+    if (state.target == JvmTarget.JVM_1_6) return true
 
     return !descriptor.isJvmDefaultOrPlatformDependent()
 }
@@ -58,7 +59,7 @@ fun isAbstractOnJvmIgnoringActualModality(jvmTarget: JvmTarget, descriptor: Func
 fun <Signature> generateBridgesForFunctionDescriptorForJvm(
     descriptor: FunctionDescriptor,
     signature: (FunctionDescriptor) -> Signature,
-    jvmTarget: JvmTarget
+    state: GenerationState
 ): Set<Bridge<Signature>> {
-    return generateBridges(DescriptorBasedFunctionHandleForJvm(descriptor, jvmTarget)) { signature(it.descriptor) }
+    return generateBridges(DescriptorBasedFunctionHandleForJvm(descriptor, state)) { signature(it.descriptor) }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/builtinSpecialBridges.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.backend.common.bridges.findAllReachableDeclarations
 import org.jetbrains.kotlin.backend.common.bridges.findConcreteSuperDeclaration
-import org.jetbrains.kotlin.config.JvmTarget
+import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
@@ -47,14 +47,14 @@ object BuiltinSpecialBridgesUtil {
     fun <Signature : Any> generateBridgesForBuiltinSpecial(
         function: FunctionDescriptor,
         signatureByDescriptor: (FunctionDescriptor) -> Signature,
-        jvmTarget: JvmTarget
+        state: GenerationState
     ): Set<BridgeForBuiltinSpecial<Signature>> {
 
-        val functionHandle = DescriptorBasedFunctionHandleForJvm(function, jvmTarget)
+        val functionHandle = DescriptorBasedFunctionHandleForJvm(function, state)
         val fake = !functionHandle.isDeclaration
         val overriddenBuiltin = function.getOverriddenBuiltinReflectingJvmDescriptor()!!
 
-        val reachableDeclarations = findAllReachableDeclarations(function, jvmTarget)
+        val reachableDeclarations = findAllReachableDeclarations(function, state)
 
         // e.g. `getSize()I`
         val methodItself = signatureByDescriptor(function)
@@ -78,11 +78,11 @@ object BuiltinSpecialBridgesUtil {
 
         if (fake) {
             for (overridden in function.overriddenDescriptors.map { it.original }) {
-                if (!DescriptorBasedFunctionHandleForJvm(overridden, jvmTarget).isAbstract) {
+                if (!DescriptorBasedFunctionHandleForJvm(overridden, state).isAbstract) {
                     commonBridges.removeAll(
                         findAllReachableDeclarations(
                             overridden,
-                            jvmTarget
+                            state
                         ).map(signatureByDescriptor)
                     )
                 }
@@ -93,7 +93,7 @@ object BuiltinSpecialBridgesUtil {
 
         val superImplementationDescriptor =
             if (specialBridge != null && fake && !functionHandle.isAbstract)
-                findSuperImplementationForStubDelegation(function, jvmTarget, signatureByDescriptor)
+                findSuperImplementationForStubDelegation(function, state, signatureByDescriptor)
             else
                 null
 
@@ -150,10 +150,10 @@ object BuiltinSpecialBridgesUtil {
  */
 private fun <Signature> findSuperImplementationForStubDelegation(
     function: FunctionDescriptor,
-    jvmTarget: JvmTarget,
+    state: GenerationState,
     signatureByDescriptor: (FunctionDescriptor) -> Signature
 ): FunctionDescriptor? {
-    val implementation = findConcreteSuperDeclaration(DescriptorBasedFunctionHandleForJvm(function, jvmTarget))
+    val implementation = findConcreteSuperDeclaration(DescriptorBasedFunctionHandleForJvm(function, state))
 
     // Implementation from interface will be generated by common mechanism
     if (!implementation.mayBeUsedAsSuperImplementation) return null
@@ -170,12 +170,12 @@ private fun <Signature> findSuperImplementationForStubDelegation(
 
 private fun findAllReachableDeclarations(
     functionDescriptor: FunctionDescriptor,
-    jvmTarget: JvmTarget
+    state: GenerationState
 ): MutableSet<FunctionDescriptor> =
     findAllReachableDeclarations(
         DescriptorBasedFunctionHandleForJvm(
             functionDescriptor,
-            jvmTarget
+            state
         )
     ).map { it.descriptor }.toMutableSet()
 

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt

@@ -115,7 +115,7 @@ class BridgeLowering(val context: JvmBackendContext) : ClassLoweringPass {
             bridgesToGenerate = generateBridgesForFunctionDescriptorForJvm(
                 descriptor,
                 getSignatureMapper(typeMapper),
-                state.target
+                state
             )
             if (!bridgesToGenerate.isEmpty()) {
                 val origin = if (descriptor.kind == DECLARATION) getSourceFromDescriptor(descriptor) else null
@@ -130,7 +130,7 @@ class BridgeLowering(val context: JvmBackendContext) : ClassLoweringPass {
             val specials = BuiltinSpecialBridgesUtil.generateBridgesForBuiltinSpecial(
                 descriptor,
                 getSignatureMapper(typeMapper),
-                state.target
+                state
             )
 
             if (!specials.isEmpty()) {