Added RpcServiceDescriptor declarations

Author: Mr3zee

core/src/commonMain/kotlin/kotlinx/rpc/awaitFieldInitialization.kt

@@ -4,10 +4,8 @@
 
 package kotlinx.rpc
 
+import kotlinx.rpc.descriptor.serviceDescriptorOf
 import kotlinx.rpc.internal.RPCDeferredField
-import kotlinx.rpc.internal.RPCServiceFieldsProvider
-import kotlinx.rpc.internal.findRPCStubProvider
-import kotlinx.rpc.internal.utils.safeCast
 import kotlin.reflect.KClass
 
 /**
@@ -81,8 +79,8 @@ public suspend inline fun <reified T : RemoteService> T.awaitFieldInitialization
  * @return specified service, after all of it's field were initialized.
  */
 public suspend fun <T : RemoteService> T.awaitFieldInitialization(kClass: KClass<T>): T {
-    findRPCStubProvider<RPCServiceFieldsProvider<T>>(kClass, RPCServiceFieldsProvider::class.safeCast())
-        .rpcFields(this)
+    serviceDescriptorOf(kClass)
+        .getFields(this)
         .forEach { field ->
             field.await()
         }

core/src/commonMain/kotlin/kotlinx/rpc/descriptor/RpcServiceDescriptor.kt

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.rpc.descriptor
+
+import kotlinx.rpc.RPCClient
+import kotlinx.rpc.RemoteService
+import kotlinx.rpc.internal.*
+import kotlinx.rpc.internal.utils.ExperimentalRPCApi
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+
+@ExperimentalRPCApi
+public inline fun <reified T : RemoteService> serviceDescriptorOf(): RpcServiceDescriptor<T> {
+    return serviceDescriptorOf(T::class)
+}
+
+@ExperimentalRPCApi
+public fun <T : RemoteService> serviceDescriptorOf(kType: KType): RpcServiceDescriptor<T> {
+    return serviceDescriptorOf(kType.kClass())
+}
+
+@ExperimentalRPCApi
+public fun <T : RemoteService> serviceDescriptorOf(kClass: KClass<T>): RpcServiceDescriptor<T> {
+    val maybeDescriptor = internalServiceDescriptorOf(kClass)
+        ?: internalError("Unable to find a service descriptor of the $kClass")
+
+    if (RpcServiceDescriptor::class.isInstance(maybeDescriptor)) {
+        @Suppress("UNCHECKED_CAST")
+        return maybeDescriptor as RpcServiceDescriptor<T>
+    }
+
+    internalError(
+        "Located descriptor object is not of a desired type ${RpcServiceDescriptor::class}, " +
+                "instead found $maybeDescriptor of the class " +
+                (maybeDescriptor::class.qualifiedClassNameOrNull ?: maybeDescriptor::class)
+    )
+}
+
+@ExperimentalRPCApi
+public interface RpcServiceDescriptor<T : RemoteService> {
+    public val fqName: String
+
+    public fun getFields(service: T): List<RPCDeferredField<*>>
+
+    public fun getCallable(name: String): RpcCallable<T>?
+
+    public fun createInstance(serviceId: Long, client: RPCClient): T
+}
+
+@ExperimentalRPCApi
+public data class RpcCallable<T : RemoteService>(
+    public val name: String,
+    public val dataType: KType,
+    public val returnType: KType,
+    public val invokator: RpcInvokator<T>,
+    public val parameters: List<RpcParameter>,
+)
+
+@ExperimentalRPCApi
+public sealed interface RpcInvokator<T : RemoteService> {
+    @ExperimentalRPCApi
+    public interface Method<T : RemoteService> : RpcInvokator<T> {
+        public suspend fun call(service: T, data: Any?): Any?
+    }
+
+    @ExperimentalRPCApi
+    public interface Field<T : RemoteService> : RpcInvokator<T> {
+        public fun call(service: T): Any?
+    }
+}
+
+@ExperimentalRPCApi
+public data class RpcParameter(val name: String, val type: KType)

core/src/commonMain/kotlin/kotlinx/rpc/internal/RPCMethodClassArguments.kt

@@ -4,8 +4,7 @@
 
 package kotlinx.rpc.internal
 
-import kotlinx.rpc.internal.utils.InternalRPCApi
+import kotlinx.rpc.RemoteService
 import kotlin.reflect.KClass
 
-@InternalRPCApi
-public expect fun <R : Any> findRPCStubProvider(kClass: KClass<*>, resultKClass: KClass<R>): R
+internal expect fun <T : RemoteService> internalServiceDescriptorOf(kClass: KClass<T>): Any?

core/src/commonMain/kotlin/kotlinx/rpc/internal/RPCStubObject.kt

@@ -5,10 +5,8 @@
 package kotlinx.rpc
 
 import kotlinx.atomicfu.atomic
-import kotlinx.rpc.internal.RPCStubServiceProvider
-import kotlinx.rpc.internal.findRPCStubProvider
+import kotlinx.rpc.descriptor.serviceDescriptorOf
 import kotlinx.rpc.internal.kClass
-import kotlinx.rpc.internal.utils.safeCast
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 
@@ -53,12 +51,9 @@ private val SERVICE_ID = atomic(0L)
  * @return instance of the generated service.
  */
 public fun <T : RemoteService> RPCClient.withService(serviceKClass: KClass<T>): T {
-    val provider = findRPCStubProvider<RPCStubServiceProvider<T>>(
-        kClass = serviceKClass,
-        resultKClass = RPCStubServiceProvider::class.safeCast(),
-    )
+    val descriptor = serviceDescriptorOf(serviceKClass)
 
     val id = SERVICE_ID.incrementAndGet()
 
-    return provider.withClient(id, this)
+    return descriptor.createInstance(id, this)
 }

core/src/commonMain/kotlin/kotlinx/rpc/internal/WithRPCStubObject.kt renamed to core/src/commonMain/kotlin/kotlinx/rpc/internal/internalServiceDescriptorOf.kt

@@ -2,12 +2,11 @@
  * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
 
-@file:Suppress("detekt.MatchingDeclarationName")
-
 package kotlinx.rpc.internal
 
 import js.objects.Object
 import kotlinx.rpc.RemoteService
+import kotlinx.rpc.descriptor.RpcServiceDescriptor
 import kotlinx.rpc.internal.utils.InternalRPCApi
 import kotlin.reflect.AssociatedObjectKey
 import kotlin.reflect.ExperimentalAssociatedObjects
@@ -18,26 +17,13 @@ import kotlin.reflect.findAssociatedObject
 @AssociatedObjectKey
 @OptIn(ExperimentalAssociatedObjects::class)
 @Target(AnnotationTarget.CLASS)
-public annotation class WithRPCStubObject(
+public annotation class WithServiceDescriptor(
     @Suppress("unused")
-    val stub: KClass<out RPCStubObject<out RemoteService>>,
+    val stub: KClass<out RpcServiceDescriptor<out RemoteService>>,
 )
 
-@InternalRPCApi
-public actual fun <R : Any> findRPCStubProvider(kClass: KClass<*>, resultKClass: KClass<R>): R {
-    val associatedObject = kClass.findAssociatedObjectImpl(WithRPCStubObject::class, resultKClass)
-        ?: internalError("Unable to find $kClass associated object")
-
-    if (resultKClass.isInstance(associatedObject)) {
-        @Suppress("UNCHECKED_CAST")
-        return associatedObject as R
-    }
-
-    internalError(
-        "Located associated object is not of desired type $resultKClass, " +
-                "instead found $associatedObject of class " +
-                (associatedObject::class.qualifiedClassNameOrNull ?: associatedObject::class.js.name)
-    )
+internal actual fun <T : RemoteService> internalServiceDescriptorOf(kClass: KClass<T>): Any? {
+    return kClass.findAssociatedObjectImpl(WithServiceDescriptor::class)
 }
 
 /**
@@ -46,22 +32,19 @@ public actual fun <R : Any> findRPCStubProvider(kClass: KClass<*>, resultKClass:
  *
  * This function uses std-lib's implementation and accounts for the bug in the compiler
  */
-internal fun <T : Annotation, R : Any> KClass<*>.findAssociatedObjectImpl(
-    annotationClass: KClass<T>,
-    resultKClass: KClass<R>,
-): Any? {
+internal fun <T : Annotation> KClass<*>.findAssociatedObjectImpl(annotationClass: KClass<T>): Any? {
     val key = annotationClass.js.asDynamic().`$metadata$`?.associatedObjectKey?.unsafeCast<Int>() ?: return null
     val map = js.asDynamic().`$metadata$`?.associatedObjects ?: return null
-    val factory = map[key] ?: return fallbackFindAssociatedObjectImpl(map, resultKClass)
+    val factory = map[key] ?: return fallbackFindAssociatedObjectImpl(map)
     return factory()
 }
 
-private fun <R : Any> fallbackFindAssociatedObjectImpl(map: dynamic, resultKClass: KClass<R>): R? {
+private fun <R : Any> fallbackFindAssociatedObjectImpl(map: dynamic): R? {
     return Object.entries(map as Any)
         .mapNotNull { (_, factory) ->
             val unsafeFactory = factory.asDynamic()
             val maybeObject = unsafeFactory()
-            if (resultKClass.isInstance(maybeObject)) {
+            if (RpcServiceDescriptor::class.isInstance(maybeObject)) {
                 maybeObject.unsafeCast<R>()
             } else {
                 null

core/src/commonMain/kotlin/kotlinx/rpc/withService.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.rpc.internal
+
+import kotlinx.rpc.RemoteService
+import kotlin.reflect.KClass
+import kotlin.reflect.full.companionObjectInstance
+
+private const val RPC_SERVICE_STUB_SIMPLE_NAME = "\$rpcServiceStub"
+
+internal actual fun <T : RemoteService> internalServiceDescriptorOf(kClass: KClass<T>): Any? {
+    val className = "${kClass.qualifiedName}\$$RPC_SERVICE_STUB_SIMPLE_NAME"
+
+    return kClass.java.classLoader
+        .loadClass(className)
+        ?.kotlin
+        ?.companionObjectInstance
+}