Updated code to use @Rpc annotation type-safety

Author: Mr3zee

compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/FirRpcCheckers.kt

@@ -16,19 +16,19 @@ import org.jetbrains.kotlin.fir.caches.firCachesFactory
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 
-class FirRpcCheckers(session: FirSession) : FirAdditionalCheckersExtension(session) {
+class FirRpcCheckers(session: FirSession, serializationIsPresent: Boolean) : FirAdditionalCheckersExtension(session) {
     override fun FirDeclarationPredicateRegistrar.registerPredicates() {
         register(FirRpcPredicates.rpc)
         register(FirRpcPredicates.checkedAnnotationMeta)
     }
 
-    private val ctx = FirCheckersContext(session)
+    private val ctx = FirCheckersContext(session, serializationIsPresent)
 
     override val declarationCheckers: DeclarationCheckers = FirRpcDeclarationCheckers(ctx)
     override val expressionCheckers: ExpressionCheckers = FirRpcExpressionCheckers(ctx)
 }
 
-class FirCheckersContext(private val session: FirSession) {
+class FirCheckersContext(private val session: FirSession, val serializationIsPresent: Boolean) {
     val typeParametersCache = session.firCachesFactory.createCache { typeParameter: FirTypeParameterSymbol ->
         FirCheckedAnnotationHelper.checkedAnnotations(session, typeParameter)
     }

compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/FirRpcExtensionRegistrar.kt

@@ -5,6 +5,7 @@
 package kotlinx.rpc.codegen
 
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
@@ -16,8 +17,20 @@ class FirRpcExtensionRegistrar(private val configuration: CompilerConfiguration)
     override fun ExtensionRegistrarContext.configurePlugin() {
         val logger = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
 
-        +CFactory { FirRpcCheckers(it)  }
-        +GFactory { FirRpcServiceGenerator(it, logger) }
+        val serializationIsPresent = try {
+            Class.forName("org.jetbrains.kotlinx.serialization.compiler.fir.SerializationFirResolveExtension")
+            +GFactory { FirRpcServiceGenerator(it, logger) }
+            true
+        } catch (_ : ClassNotFoundException) {
+            logger.report(
+                severity = CompilerMessageSeverity.INFO,
+                message = "Serialization plugin is not found, so generated services are not available",
+            )
+            false
+        }
+
+        +CFactory { FirRpcCheckers(it, serializationIsPresent) }
+
         +SFactory { FirRpcSupertypeGenerator(it, logger) }
     }
 }

compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/FirRpcServiceGenerator.kt

@@ -67,7 +67,10 @@ class FirRpcServiceGenerator(
     @Suppress("unused")
     private val logger: MessageCollector,
 ) : FirDeclarationGenerationExtension(session) {
-    private val serializationExtension = SerializationFirResolveExtension(session)
+    private val serializationExtension by lazy {
+        SerializationFirResolveExtension(session)
+    }
+
     private val isJvmOrMetadata = !session.moduleData.platform.run { isJs() || isWasm() || isNative() }
 
     override fun FirDeclarationPredicateRegistrar.registerPredicates() {

compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcAnnotationChecker.kt

@@ -4,6 +4,7 @@
 
 package kotlinx.rpc.codegen.checkers
 
+import kotlinx.rpc.codegen.FirCheckersContext
 import kotlinx.rpc.codegen.FirRpcPredicates
 import kotlinx.rpc.codegen.checkers.diagnostics.FirRpcDiagnostics
 import kotlinx.rpc.codegen.isRemoteService
@@ -18,7 +19,7 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.isInterface
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 
-object FirRpcAnnotationChecker : FirRegularClassChecker(MppCheckerKind.Common) {
+class FirRpcAnnotationChecker(private val ctx: FirCheckersContext) : FirRegularClassChecker(MppCheckerKind.Common) {
     override fun check(
         declaration: FirRegularClass,
         context: CheckerContext,
@@ -41,5 +42,13 @@ object FirRpcAnnotationChecker : FirRegularClassChecker(MppCheckerKind.Common) {
                 context = context,
             )
         }
+
+        if (rpcAnnotated && !ctx.serializationIsPresent) {
+            reporter.reportOn(
+                source = declaration.symbol.rpcAnnotationSource(context.session),
+                factory = FirRpcDiagnostics.MISSING_SERIALIZATION_MODULE,
+                context = context,
+            )
+        }
     }
 }

compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcDeclarationCheckers.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChec
 
 class FirRpcDeclarationCheckers(ctx: FirCheckersContext) : DeclarationCheckers() {
     override val regularClassCheckers: Set<FirRegularClassChecker> = setOf(
-        FirRpcAnnotationChecker,
+        FirRpcAnnotationChecker(ctx),
     )
 
     override val classCheckers: Set<FirClassChecker> = setOf(

compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/diagnostics/FirRpcDiagnostics.kt

@@ -7,11 +7,13 @@ package kotlinx.rpc.codegen.checkers.diagnostics
 import org.jetbrains.kotlin.diagnostics.error0
 import org.jetbrains.kotlin.diagnostics.error1
 import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
+import org.jetbrains.kotlin.diagnostics.warning0
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.psi.KtAnnotationEntry
 
 object FirRpcDiagnostics {
     val MISSING_RPC_ANNOTATION by error0<KtAnnotationEntry>()
+    val MISSING_SERIALIZATION_MODULE by warning0<KtAnnotationEntry>()
     val WRONG_RPC_ANNOTATION_TARGET by error0<KtAnnotationEntry>()
     val CHECKED_ANNOTATION_VIOLATION by error1<KtAnnotationEntry, ConeKotlinType>()
 

compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/diagnostics/RpcDiagnosticRendererFactory.kt

@@ -17,6 +17,13 @@ object RpcDiagnosticRendererFactory : BaseDiagnosticRendererFactory() {
                     "must be annotated with kotlinx.rpc.annotations.Rpc",
         )
 
+        put(
+            factory = FirRpcDiagnostics.MISSING_SERIALIZATION_MODULE,
+            message = "Missing kotlinx.serialization plugin in the module. " +
+                    "Service generation will not be available. " +
+                    "Add kotlin(\"plugin.serialization\") to your build.gradle.kts plugins section."
+        )
+
         put(
             factory = FirRpcDiagnostics.WRONG_RPC_ANNOTATION_TARGET,
             message = "@Rpc annotation is only applicable to interfaces.",

core/build.gradle.kts

@@ -7,6 +7,7 @@ import util.applyAtomicfuPlugin
 plugins {
     alias(libs.plugins.conventions.kmp)
     alias(libs.plugins.serialization)
+    alias(libs.plugins.kotlinx.rpc)
 }
 
 applyAtomicfuPlugin()

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

@@ -5,6 +5,7 @@
 package kotlinx.rpc
 
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.rpc.annotations.Rpc
 import kotlin.coroutines.CoroutineContext
 import kotlin.reflect.KClass
 
@@ -27,7 +28,7 @@ public interface RpcServer : CoroutineScope {
      * @param serviceKClass [KClass] of the [Service].
      * @param serviceFactory function that produces the actual implementation of the service that will handle the calls.
      */
-    public fun <Service : RemoteService> registerService(
+    public fun <@Rpc Service : Any> registerService(
         serviceKClass: KClass<Service>,
         serviceFactory: (CoroutineContext) -> Service,
     )
@@ -42,7 +43,7 @@ public interface RpcServer : CoroutineScope {
  * type `MyService` should be specified explicitly.
  * @param serviceFactory function that produces the actual implementation of the service that will handle the calls.
  */
-public inline fun <reified Service : RemoteService> RpcServer.registerService(
+public inline fun <@Rpc reified Service : Any> RpcServer.registerService(
     noinline serviceFactory: (CoroutineContext) -> Service,
 ) {
     registerService(Service::class, serviceFactory)

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

@@ -4,6 +4,7 @@
 
 package kotlinx.rpc
 
+import kotlinx.rpc.annotations.Rpc
 import kotlinx.rpc.descriptor.serviceDescriptorOf
 import kotlinx.rpc.internal.RpcDeferredField
 import kotlin.reflect.KClass
@@ -26,7 +27,7 @@ import kotlin.reflect.KClass
  * @param getter function that returns the field of the context service to wait for.
  * @return service filed after it was initialized.
  */
-public suspend fun <T : RemoteService, R> T.awaitFieldInitialization(getter: T.() -> R): R {
+public suspend fun <@Rpc T : Any, R> T.awaitFieldInitialization(getter: T.() -> R): R {
     val field = getter()
 
     if (field is RpcDeferredField<*>) {
@@ -55,7 +56,7 @@ public suspend fun <T : RemoteService, R> T.awaitFieldInitialization(getter: T.(
  * @param T service type
  * @return specified service, after all of it's field were initialized.
  */
-public suspend inline fun <reified T : RemoteService> T.awaitFieldInitialization(): T {
+public suspend inline fun <@Rpc reified T : Any> T.awaitFieldInitialization(): T {
     return awaitFieldInitialization(T::class)
 }
 
@@ -78,7 +79,7 @@ public suspend inline fun <reified T : RemoteService> T.awaitFieldInitialization
  * @param kClass [KClass] of the [T] type.
  * @return specified service, after all of it's field were initialized.
  */
-public suspend fun <T : RemoteService> T.awaitFieldInitialization(kClass: KClass<T>): T {
+public suspend fun <@Rpc T : Any> T.awaitFieldInitialization(kClass: KClass<T>): T {
     serviceDescriptorOf(kClass)
         .getFields(this)
         .forEach { field ->