gRPC Initial Implementation (#262)

Author: Mr3zee

build.gradle.kts

@@ -9,6 +9,7 @@ plugins {
     alias(libs.plugins.kotlinx.rpc) apply false
     alias(libs.plugins.atomicfu) apply false
     alias(libs.plugins.conventions.kover)
+    alias(libs.plugins.protobuf) apply false
     alias(libs.plugins.conventions.gradle.doctor)
     alias(libs.plugins.conventions.root)
 }

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

@@ -73,6 +73,14 @@ internal class RpcIrContext(
         getRpcIrClassSymbol("RpcServiceDescriptor", "descriptor")
     }
 
+    val grpcServiceDescriptor by lazy {
+        getIrClassSymbol("kotlinx.rpc.grpc.descriptor", "GrpcServiceDescriptor")
+    }
+
+    val grpcDelegate by lazy {
+        getIrClassSymbol("kotlinx.rpc.grpc.descriptor", "GrpcDelegate")
+    }
+
     val rpcType by lazy {
         getRpcIrClassSymbol("RpcType", "descriptor")
     }
@@ -210,6 +218,10 @@ internal class RpcIrContext(
             rpcServiceDescriptor.namedProperty("fqName")
         }
 
+        val grpcServiceDescriptorDelegate by lazy {
+            grpcServiceDescriptor.namedProperty("delegate")
+        }
+
         private fun IrClassSymbol.namedProperty(name: String): IrPropertySymbol {
             return owner.properties.single { it.name.asString() == name }.symbol
         }
@@ -224,7 +236,7 @@ internal class RpcIrContext(
         return getIrClassSymbol("kotlinx.rpc$suffix", name)
     }
 
-    private fun getIrClassSymbol(packageName: String, name: String): IrClassSymbol {
+    fun getIrClassSymbol(packageName: String, name: String): IrClassSymbol {
         return versionSpecificApi.referenceClass(pluginContext, packageName, name)
             ?: error("Unable to find symbol. Package: $packageName, name: $name")
     }

compiler-plugin/compiler-plugin-backend/src/main/kotlin/kotlinx/rpc/codegen/extension/RpcIrServiceProcessor.kt

@@ -15,7 +15,9 @@ internal class RpcIrServiceProcessor(
     private val logger: MessageCollector,
 ) {
     fun visitClass(declaration: IrClass, data: RpcIrContext) {
-        if (declaration.hasAnnotation(RpcClassId.rpcAnnotation) && declaration.isInterface) {
+        if ((declaration.hasAnnotation(RpcClassId.rpcAnnotation)
+            || declaration.hasAnnotation(RpcClassId.grpcAnnotation)) && declaration.isInterface
+        ) {
             processService(declaration, data)
         }
     }

compiler-plugin/compiler-plugin-backend/src/main/kotlin/kotlinx/rpc/codegen/extension/RpcStubGenerator.kt

@@ -41,6 +41,10 @@ private object Descriptor {
     const val CREATE_INSTANCE = "createInstance"
 }
 
+private object GrpcDescriptor {
+    const val DELEGATE = "delegate"
+}
+
 @Suppress("detekt.LargeClass", "detekt.TooManyFunctions")
 internal class RpcStubGenerator(
     private val declaration: ServiceDeclaration,
@@ -450,7 +454,10 @@ internal class RpcStubGenerator(
             stubCompanionObjectThisReceiver = thisReceiver
                 ?: error("Stub companion object expected to have thisReceiver: ${name.asString()}")
 
-            superTypes = listOf(ctx.rpcServiceDescriptor.typeWith(declaration.serviceType))
+            superTypes = listOfNotNull(
+                ctx.rpcServiceDescriptor.typeWith(declaration.serviceType),
+                if (declaration.isGrpc) ctx.grpcServiceDescriptor.typeWith(declaration.serviceType) else null,
+            )
 
             generateCompanionObjectConstructor()
 
@@ -481,6 +488,10 @@ internal class RpcStubGenerator(
         generateGetCallableFunction()
 
         generateCreateInstanceFunction()
+
+        if (declaration.isGrpc) {
+            generateGrpcDelegateProperty()
+        }
     }
 
     /**
@@ -991,6 +1002,42 @@ internal class RpcStubGenerator(
         }
     }
 
+    /**
+     * override val delegate: GrpcDelegate = MyServiceDelegate
+     */
+    private fun IrClass.generateGrpcDelegateProperty() {
+        addProperty {
+            name = Name.identifier(GrpcDescriptor.DELEGATE)
+            visibility = DescriptorVisibilities.PUBLIC
+        }.apply {
+            overriddenSymbols = listOf(ctx.properties.grpcServiceDescriptorDelegate)
+
+            addBackingFieldUtil {
+                visibility = DescriptorVisibilities.PRIVATE
+                type = ctx.grpcDelegate.defaultType
+                vsApi { isFinalVS = true }
+            }.apply {
+                initializer = factory.createExpressionBody(
+                    IrGetObjectValueImpl(
+                        startOffset = UNDEFINED_OFFSET,
+                        endOffset = UNDEFINED_OFFSET,
+                        type = ctx.grpcDelegate.defaultType,
+                        symbol = ctx.getIrClassSymbol(
+                            declaration.service.packageFqName?.asString()
+                                ?: error("Expected package name fro service ${declaration.service.name}"),
+                            "${declaration.service.name.asString()}Delegate",
+                        ),
+                    )
+                )
+            }
+
+            addDefaultGetter(this@generateGrpcDelegateProperty, ctx.irBuiltIns) {
+                visibility = DescriptorVisibilities.PUBLIC
+                overriddenSymbols = listOf(ctx.properties.grpcServiceDescriptorDelegate.owner.getterOrFail.symbol)
+            }
+        }
+    }
+
     // Associated object annotation works on JS, WASM, and Native platforms.
     // See https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.reflect/find-associated-object.html
     private fun addAssociatedObjectAnnotationIfPossible() {

compiler-plugin/compiler-plugin-backend/src/main/kotlin/kotlinx/rpc/codegen/extension/ServiceDeclaration.kt

@@ -4,19 +4,22 @@
 
 package kotlinx.rpc.codegen.extension
 
+import kotlinx.rpc.codegen.common.RpcClassId
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrProperty
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.declarations.IrValueParameter
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.defaultType
+import org.jetbrains.kotlin.ir.util.hasAnnotation
 import org.jetbrains.kotlin.ir.util.kotlinFqName
 
 class ServiceDeclaration(
     val service: IrClass,
     val stubClass: IrClass,
     val methods: List<Method>,
 ) {
+    val isGrpc = service.hasAnnotation(RpcClassId.grpcAnnotation)
     val fqName = service.kotlinFqName.asString()
 
     val serviceType = service.defaultType

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

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.name.Name
 
 object RpcClassId {
     val rpcAnnotation = ClassId(FqName("kotlinx.rpc.annotations"), Name.identifier("Rpc"))
+    val grpcAnnotation = ClassId(FqName("kotlinx.rpc.grpc.annotations"), Name.identifier("Grpc"))
     val checkedTypeAnnotation = ClassId(FqName("kotlinx.rpc.annotations"), Name.identifier("CheckedTypeAnnotation"))
 
     val serializableAnnotation = ClassId(FqName("kotlinx.serialization"), Name.identifier("Serializable"))

compiler-plugin/compiler-plugin-k2/src/main/kotlin/kotlinx/rpc/codegen/FirGenerationKeys.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 
 internal class RpcGeneratedStubKey(
+    val isGrpc: Boolean,
     private val serviceName: Name,
 ) : GeneratedDeclarationKey() {
     override fun toString(): String {

compiler-plugin/compiler-plugin-k2/src/main/kotlin/kotlinx/rpc/codegen/FirRpcAdditionalCheckers.kt

@@ -23,6 +23,7 @@ class FirRpcAdditionalCheckers(
 ) : FirAdditionalCheckersExtension(session) {
     override fun FirDeclarationPredicateRegistrar.registerPredicates() {
         register(FirRpcPredicates.rpc)
+        register(FirRpcPredicates.grpc)
         register(FirRpcPredicates.checkedAnnotationMeta)
     }
 

compiler-plugin/compiler-plugin-k2/src/main/kotlin/kotlinx/rpc/codegen/FirRpcPredicates.kt

@@ -16,6 +16,10 @@ object FirRpcPredicates {
         metaAnnotated(RpcClassId.rpcAnnotation.asSingleFqName(), includeItself = true)
     }
 
+    internal val grpc = DeclarationPredicate.create {
+        annotated(RpcClassId.grpcAnnotation.asSingleFqName()) // @Grpc
+    }
+
     internal val checkedAnnotationMeta = DeclarationPredicate.create {
         metaAnnotated(RpcClassId.checkedTypeAnnotation.asSingleFqName(), includeItself = false)
     }

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

@@ -23,6 +23,7 @@ class FirRpcServiceGenerator(
 ) : FirDeclarationGenerationExtension(session) {
     override fun FirDeclarationPredicateRegistrar.registerPredicates() {
         register(FirRpcPredicates.rpc)
+        register(FirRpcPredicates.grpc)
     }
 
     /**
@@ -51,7 +52,10 @@ class FirRpcServiceGenerator(
                 setOf(SpecialNames.DEFAULT_NAME_FOR_COMPANION_OBJECT)
             }
 
-            classSymbol.isInterface && session.predicateBasedProvider.matches(FirRpcPredicates.rpc, classSymbol) -> {
+            classSymbol.isInterface && (
+                    session.predicateBasedProvider.matches(FirRpcPredicates.rpc, classSymbol) ||
+                            session.predicateBasedProvider.matches(FirRpcPredicates.grpc, classSymbol)
+                    ) -> {
                 setOf(RpcNames.SERVICE_STUB_NAME)
             }