Rename RPC -> RemoteService; Add @rpc checks and usages

Author: Mr3zee

README.md

@@ -17,11 +17,13 @@ Build your RPC with already known language constructs and nothing more!
 
 ## Quick start
 
-First, create your `RPC` service and define some methods:
+First, create your RPC service and define some methods:
 ```kotlin
-import kotlinx.rpc.RPC
+import kotlinx.rpc.RemoteService
+import kotlinx.rpc.annotations.Rpc
 
-interface AwesomeService : RPC {
+@Rpc
+interface AwesomeService : RemoteService {
     suspend fun getNews(city: String): Flow<String>
 }
 ```

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

@@ -94,8 +94,8 @@ internal object RPCDeclarationScanner {
 
 private fun unsupportedDeclaration(service: IrClass, declaration: IrDeclaration, logger: MessageCollector): Nothing? {
     logger.report(
-        severity = CompilerMessageSeverity.WARNING,
-        message = "Unsupported declaration in RPC interface ${service.name}: ${declaration.dumpKotlinLike()}",
+        severity = CompilerMessageSeverity.LOGGING,
+        message = "Unsupported declaration in RemoteService interface ${service.name}: ${declaration.dumpKotlinLike()}",
     )
 
     return null

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

@@ -77,10 +77,6 @@ internal class RPCIrContext(
         getIrClassSymbol("kotlin", "Pair")
     }
 
-    val rpc by lazy {
-        getRpcIrClassSymbol("RPC")
-    }
-
     val rpcClient by lazy {
         getRpcIrClassSymbol("RPCClient")
     }

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

@@ -4,24 +4,23 @@
 
 package kotlinx.rpc.codegen.extension
 
+import kotlinx.rpc.codegen.common.RpcClassId
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.types.defaultType
-import org.jetbrains.kotlin.ir.util.isInterface
+import org.jetbrains.kotlin.ir.util.hasAnnotation
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 
 internal class RPCIrServiceProcessor(
     @Suppress("unused")
     private val logger: MessageCollector,
 ) : IrElementTransformer<RPCIrContext> {
-    @Suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE")
-    override fun visitClass(declaration: IrClass, context: RPCIrContext): IrStatement {
-        if (declaration.isInterface && declaration.superTypes.contains(context.rpc.defaultType)) {
-            processService(declaration, context)
+    override fun visitClass(declaration: IrClass, data: RPCIrContext): IrStatement {
+        if (declaration.hasAnnotation(RpcClassId.rpcAnnotation)) {
+            processService(declaration, data)
         }
 
-        return super.visitClass(declaration, context)
+        return super.visitClass(declaration, data)
     }
 
     private fun processService(service: IrClass, context: RPCIrContext) {

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

@@ -196,7 +196,7 @@ internal class RPCStubGenerator(
     private var coroutineContextProperty: IrProperty by Delegates.notNull()
 
     /**
-     * `coroutineContext` property from `RPC` interface
+     * `coroutineContext` property from `RemoteService` interface
      *
      * ```kotlin
      * final override val coroutineContext: CoroutineContext = __rpc_client.provideStubContext(__rpc_stub_id)

compiler-plugin/compiler-plugin-common/src/main/core/kotlinx/rpc/codegen/common/Names.kt

@@ -9,8 +9,8 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
 object RpcClassId {
-    val rpcInterface = ClassId(FqName("kotlinx.rpc"), Name.identifier("RPC"))
-    val rpcAnnotation = ClassId(FqName("kotlinx.rpc"), Name.identifier("Rpc"))
+    val remoteServiceInterface = ClassId(FqName("kotlinx.rpc"), Name.identifier("RemoteService"))
+    val rpcAnnotation = ClassId(FqName("kotlinx.rpc.annotations"), Name.identifier("Rpc"))
 
     val serializableAnnotation = ClassId(FqName("kotlinx.serialization"), Name.identifier("Serializable"))
     val contextualAnnotation = ClassId(FqName("kotlinx.serialization"), Name.identifier("Contextual"))

compiler-plugin/compiler-plugin-k2/src/main/latest/kotlinx/rpc/codegen/FirRpcSupertypeGenerator.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
 import org.jetbrains.kotlin.fir.extensions.FirSupertypeGenerationExtension
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.classId
 import org.jetbrains.kotlin.fir.types.constructClassLikeType
 import org.jetbrains.kotlin.fir.types.toFirResolvedTypeRef
 
@@ -33,12 +32,12 @@ class FirRpcSupertypeGenerator(
         resolvedSupertypes: List<FirResolvedTypeRef>,
         typeResolver: TypeResolveService,
     ): List<FirResolvedTypeRef> {
-        if (resolvedSupertypes.any { it.type.classId == RpcClassId.rpcInterface }) {
+        if (resolvedSupertypes.any { it.doesMatchesClassId(session, RpcClassId.remoteServiceInterface) }) {
             return emptyList()
         }
 
         return listOf(
-            RpcClassId.rpcInterface
+            RpcClassId.remoteServiceInterface
                 .constructClassLikeType(emptyArray(), isNullable = false)
                 .toFirResolvedTypeRef()
         )

compiler-plugin/compiler-plugin-k2/src/main/latest/kotlinx/rpc/codegen/FirRpcUtils.kt

@@ -9,12 +9,17 @@ import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.types.classId
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.coneTypeSafe
+import org.jetbrains.kotlin.name.ClassId
 
-fun FirClassSymbol<*>.isRpc(): Boolean = resolvedSuperTypes.any {
-    it.classId == RpcClassId.rpcInterface
+fun FirClassSymbol<*>.isRemoteService(session: FirSession): Boolean = resolvedSuperTypeRefs.any {
+    it.doesMatchesClassId(session, RpcClassId.remoteServiceInterface)
 }
 
 fun FirBasedSymbol<*>.rpcAnnotationSource(session: FirSession): KtSourceElement? {
@@ -28,3 +33,15 @@ fun FirBasedSymbol<*>.rpcAnnotation(session: FirSession): FirAnnotation? {
 fun List<FirAnnotation>.rpcAnnotation(session: FirSession): FirAnnotation? {
     return getAnnotationByClassId(RpcClassId.rpcAnnotation, session)
 }
+
+fun FirClassSymbol<*>.remoteServiceSupertypeSource(session: FirSession): KtSourceElement? {
+    return remoteServiceSupertype(session)?.source
+}
+
+fun FirClassSymbol<*>.remoteServiceSupertype(session: FirSession): FirResolvedTypeRef? {
+    return resolvedSuperTypeRefs.find { it.doesMatchesClassId(session, RpcClassId.remoteServiceInterface) }
+}
+
+internal fun FirTypeRef.doesMatchesClassId(session: FirSession, classId: ClassId): Boolean {
+    return coneTypeSafe<ConeClassLikeType>()?.fullyExpandedType(session)?.lookupTag?.classId == classId
+}

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

@@ -6,7 +6,8 @@ package kotlinx.rpc.codegen.checkers
 
 import kotlinx.rpc.codegen.FirRpcPredicates
 import kotlinx.rpc.codegen.checkers.diagnostics.FirRpcDiagnostics
-import kotlinx.rpc.codegen.isRpc
+import kotlinx.rpc.codegen.isRemoteService
+import kotlinx.rpc.codegen.remoteServiceSupertypeSource
 import kotlinx.rpc.codegen.rpcAnnotationSource
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.reportOn
@@ -33,9 +34,9 @@ object FirRpcAnnotationChecker : FirRegularClassChecker(MppCheckerKind.Common) {
             )
         }
 
-        if (declaration.symbol.isRpc() && !rpcAnnotated) {
+        if (declaration.symbol.isRemoteService(context.session) && !rpcAnnotated) {
             reporter.reportOn(
-                source = declaration.symbol.rpcAnnotationSource(context.session),
+                source = declaration.symbol.remoteServiceSupertypeSource(context.session),
                 factory = FirRpcDiagnostics.MISSING_RPC_ANNOTATION,
                 context = context,
             )

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

@@ -12,8 +12,10 @@ object RpcDiagnosticRendererFactory : BaseDiagnosticRendererFactory() {
         put(
             factory = FirRpcDiagnostics.MISSING_RPC_ANNOTATION,
             message = "Missing @Rpc annotation. " +
-                    "All services children of kotlinx.rpc.RPC must be annotated with @Rpc (from kotlinx.rpc package).",
+                    "All services children of kotlinx.rpc.RemoteService " +
+                    "must be annotated with kotlinx.rpc.annotations.Rpc",
         )
+
         put(
             factory = FirRpcDiagnostics.WRONG_RPC_ANNOTATION_TARGET,
             message = "@Rpc annotation is only applicable to interfaces.",