Merge pull request #345 from DataDog/yl/kcp/kotlin-1.9-back-compact

Enhance compiler plugin binary backward compatibility

Author: ambushwork

dd-sdk-android-gradle-plugin/src/main/kotlin/com/datadog/gradle/plugin/kcp/IrExt.kt

@@ -6,13 +6,14 @@ import org.jetbrains.kotlin.descriptors.DescriptorVisibility
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOriginImpl
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
-import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.expressions.IrFunctionExpression
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
+import org.jetbrains.kotlin.ir.expressions.IrStatementOriginImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionExpressionImpl
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
@@ -23,30 +24,33 @@ import org.jetbrains.kotlin.ir.util.defaultType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+import kotlin.reflect.KVisibility
+import kotlin.reflect.full.createInstance
+import kotlin.reflect.full.primaryConstructor
 
 // Builds Lambda of (T.() -> Unit)
 internal fun IrPluginContext.irUnitLambdaExpression(
     body: IrBody,
     irDeclarationParent: IrDeclarationParent?,
     receiverType: IrType
 ): IrFunctionExpression {
-    return irFunctionExpression(
+    return buildCompatIrFunctionExpression(
         symbols.irBuiltIns.functionN(0).defaultType,
         irSimpleFunction(
             name = SpecialNames.ANONYMOUS,
             visibility = DescriptorVisibilities.LOCAL,
             returnType = symbols.unit.defaultType,
-            origin = IrDeclarationOrigin.LOCAL_FUNCTION_FOR_LAMBDA,
+            origin = getCompatLambdaOrigin(),
             body = body
         ).apply {
             irDeclarationParent?.let {
                 this.parent = irDeclarationParent
             }
-            this.extensionReceiverParameter = irFactory.createValueParameter(
+            this.extensionReceiverParameter = IrFactoryImpl.createValueParameter(
                 startOffset,
                 endOffset,
-                IrDeclarationOrigin.DEFINED,
-                symbol = IrValueParameterSymbolImpl(),
+                getCompatDefinedOrigin(),
+                symbol = getCompatValueParameterSymbolImpl(),
                 name = Name.identifier("receiver"),
                 index = -1,
                 type = receiverType,
@@ -64,26 +68,13 @@ internal fun IrPluginContext.irUnitLambdaExpression(
     )
 }
 
-internal fun irFunctionExpression(
-    type: IrType,
-    function: IrSimpleFunction
-): IrFunctionExpression {
-    return IrFunctionExpressionImpl(
-        UNDEFINED_OFFSET,
-        UNDEFINED_OFFSET,
-        type,
-        function,
-        IrStatementOrigin.LAMBDA
-    )
-}
-
 internal fun irSimpleFunction(
     name: Name,
     visibility: DescriptorVisibility,
     returnType: IrType,
     origin: IrDeclarationOrigin,
     body: IrBody,
-    symbol: IrSimpleFunctionSymbol = IrSimpleFunctionSymbolImpl(),
+    symbol: IrSimpleFunctionSymbol = getCompatSimpleFunctionSymbol(),
     modality: Modality = Modality.FINAL,
     isInline: Boolean = false,
     isExternal: Boolean = false,
@@ -92,10 +83,9 @@ internal fun irSimpleFunction(
     isOperator: Boolean = false,
     isInfix: Boolean = false,
     isExpect: Boolean = false,
-    isFakeOverride: Boolean = origin == IrDeclarationOrigin.FAKE_OVERRIDE,
-    containerSource: DeserializedContainerSource? = null,
-    factory: IrFactory = IrFactoryImpl
-): IrSimpleFunction = factory.createSimpleFunction(
+    isFakeOverride: Boolean = origin == getCompatFakeOverrideOrigin(),
+    containerSource: DeserializedContainerSource? = null
+): IrSimpleFunction = IrFactoryImpl.createSimpleFunction(
     startOffset = UNDEFINED_OFFSET,
     endOffset = UNDEFINED_OFFSET,
     origin = origin,
@@ -116,3 +106,78 @@ internal fun irSimpleFunction(
 ).apply {
     this.body = body
 }
+
+private fun getCompatLambdaOrigin(): IrDeclarationOriginImpl {
+    return getCompatDeclarationOrigin("LOCAL_FUNCTION_FOR_LAMBDA") {
+        IrDeclarationOrigin.LOCAL_FUNCTION_FOR_LAMBDA
+    }
+}
+
+private fun getCompatFakeOverrideOrigin(): IrDeclarationOriginImpl {
+    return getCompatDeclarationOrigin("FAKE_OVERRIDE") {
+        IrDeclarationOrigin.FAKE_OVERRIDE
+    }
+}
+
+private fun getCompatDefinedOrigin(): IrDeclarationOriginImpl {
+    return getCompatDeclarationOrigin("DEFINED") {
+        IrDeclarationOrigin.DEFINED
+    }
+}
+
+private fun getCompatDeclarationOrigin(
+    name: String,
+    default: () -> IrDeclarationOriginImpl
+): IrDeclarationOriginImpl {
+    // In Kotlin 1.9, `IrDeclarationOriginImpl` is an abstract class, not in 2.0
+    return if (IrDeclarationOriginImpl::class.isAbstract) {
+        val nestedClass = IrDeclarationOrigin::class.nestedClasses
+            .firstOrNull { it.simpleName == name }
+        val instance = nestedClass?.objectInstance
+        instance as IrDeclarationOriginImpl
+    } else {
+        default.invoke()
+    }
+}
+
+private fun getCompatLambdaStateOrigin(): IrStatementOriginImpl {
+    // In Kotlin 1.9, `IrStatementOriginImpl` is an abstract class, not in 2.0
+    return if (IrStatementOriginImpl::class.isAbstract) {
+        val lambdaClass = IrStatementOrigin::class.nestedClasses
+            .firstOrNull { it.simpleName == "LAMBDA" }
+        val instance = lambdaClass?.objectInstance
+        return instance as IrStatementOriginImpl
+    } else {
+        IrStatementOrigin.LAMBDA
+    }
+}
+
+private fun getCompatSimpleFunctionSymbol(): IrSimpleFunctionSymbol {
+    return IrSimpleFunctionSymbolImpl::class.createInstance()
+}
+
+private fun getCompatValueParameterSymbolImpl(): IrValueParameterSymbolImpl {
+    return IrValueParameterSymbolImpl::class.createInstance()
+}
+
+private fun buildCompatIrFunctionExpression(
+    type: IrType,
+    function: IrSimpleFunction
+): IrFunctionExpression {
+    val primaryConstructor = IrFunctionExpressionImpl::class.primaryConstructor
+    return primaryConstructor?.takeIf {
+        it.visibility == KVisibility.PUBLIC
+    }?.call(
+        UNDEFINED_OFFSET,
+        UNDEFINED_OFFSET,
+        type,
+        function,
+        getCompatLambdaStateOrigin()
+    ) ?: IrFunctionExpressionImpl(
+        UNDEFINED_OFFSET,
+        UNDEFINED_OFFSET,
+        type,
+        function,
+        getCompatLambdaStateOrigin()
+    )
+}