Serialization decoupling (#354)

Author: Mr3zee

compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/VersionSpecificApi.kt

@@ -14,6 +14,8 @@ import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.ir.builders.declarations.IrFieldBuilder
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrCall
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
@@ -53,6 +55,12 @@ interface VersionSpecificApi {
 
     var IrConstructor.isPrimaryVS: Boolean
 
+    val IrConstructor.parametersVS: List<IrValueParameter>
+
+    val IrConstructorCall.argumentsVS: List<IrExpression?>
+
+    fun IrType.isNullableVS(): Boolean
+
     val messageCollectorKey: CompilerConfigurationKey<MessageCollector>
 
     companion object {

compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcIrContext.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.types.makeNullable
+import org.jetbrains.kotlin.ir.types.typeWith
 import org.jetbrains.kotlin.ir.util.functions
 import org.jetbrains.kotlin.ir.util.isVararg
 import org.jetbrains.kotlin.ir.util.nestedClasses
@@ -32,6 +33,14 @@ internal class RpcIrContext(
         irBuiltIns.arrayClass.typeWith(anyNullable, Variance.OUT_VARIANCE)
     }
 
+    val listOfAnnotations by lazy {
+        irBuiltIns.listClass.typeWith(irBuiltIns.annotationType)
+    }
+
+    val arrayOfAnnotations by lazy {
+        irBuiltIns.arrayClass.typeWith(irBuiltIns.annotationType, Variance.OUT_VARIANCE)
+    }
+
     val kTypeClass by lazy {
         getIrClassSymbol("kotlin.reflect", "KType")
     }
@@ -68,10 +77,22 @@ internal class RpcIrContext(
         getRpcIrClassSymbol("RpcType", "descriptor")
     }
 
+    val rpcTypeDefault by lazy {
+        getRpcIrClassSymbol("RpcTypeDefault", "descriptor")
+    }
+
+    val rpcTypeKrpc by lazy {
+        getRpcIrClassSymbol("RpcTypeKrpc", "descriptor")
+    }
+
     val rpcCallable by lazy {
         getRpcIrClassSymbol("RpcCallable", "descriptor")
     }
 
+    val rpcCallableDefault by lazy {
+        getRpcIrClassSymbol("RpcCallableDefault", "descriptor")
+    }
+
     private val rpcInvokator by lazy {
         getRpcIrClassSymbol("RpcInvokator", "descriptor")
     }
@@ -84,8 +105,20 @@ internal class RpcIrContext(
         getRpcIrClassSymbol("RpcParameter", "descriptor")
     }
 
-    val rpcMethodClass by lazy {
-        getRpcIrClassSymbol("RpcMethodClass", "internal")
+    val rpcParameterDefault by lazy {
+        getRpcIrClassSymbol("RpcParameterDefault", "descriptor")
+    }
+
+    val kSerializer by lazy {
+        getIrClassSymbol("kotlinx.serialization", "KSerializer")
+    }
+
+    val kSerializerAnyNullable by lazy {
+        kSerializer.typeWith(anyNullable)
+    }
+
+    val kSerializerAnyNullableKClass by lazy {
+        irBuiltIns.kClassClass.typeWith(kSerializerAnyNullable)
     }
 
     fun isJsTarget(): Boolean {
@@ -103,10 +136,6 @@ internal class RpcIrContext(
     val functions = Functions()
 
     inner class Functions {
-        val dataCast by lazy {
-            namedFunction("kotlinx.rpc.internal", "rpcInternalDataCast")
-        }
-
         val rpcClientCall by lazy {
             rpcClient.namedFunction("call")
         }
@@ -115,10 +144,6 @@ internal class RpcIrContext(
             rpcClient.namedFunction("callServerStreaming")
         }
 
-        val asArray by lazy {
-            rpcMethodClass.namedFunction("asArray")
-        }
-
         val typeOf by lazy {
             namedFunction("kotlin.reflect", "typeOf")
         }
@@ -135,10 +160,26 @@ internal class RpcIrContext(
             }
         }
 
+        val emptyList by lazy {
+            namedFunction("kotlin.collections", "emptyList")
+        }
+
+        val listOf by lazy {
+            namedFunction("kotlin.collections", "listOf") {
+                vsApi {
+                    it.owner.valueParametersVS().singleOrNull()?.isVararg ?: false
+                }
+            }
+        }
+
         val mapGet by lazy {
             irBuiltIns.mapClass.namedFunction("get")
         }
 
+        val arrayGet by lazy {
+            irBuiltIns.arrayClass.namedFunction("get")
+        }
+
         val emptyMap by lazy {
             namedFunction("kotlin.collections", "emptyMap")
         }