grpc: Separate between kotlin FQ name and service (grpc) FQ name

Signed-off-by: Johannes Zottele <[email protected]>

Author: Jozott00

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

@@ -11,8 +11,13 @@ import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.declarations.IrProperty
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.expressions.IrConst
+import org.jetbrains.kotlin.ir.expressions.IrConstKind
+import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.util.dumpKotlinLike
+import org.jetbrains.kotlin.ir.util.getAnnotation
 import org.jetbrains.kotlin.ir.util.hasDefaultValue
+import org.jetbrains.kotlin.ir.util.kotlinFqName
 
 /**
  * This class scans user declared RPC service
@@ -25,6 +30,9 @@ internal object RpcDeclarationScanner {
     fun scanServiceDeclaration(service: IrClass, ctx: RpcIrContext, logger: MessageCollector): ServiceDeclaration {
         var stubClass: IrClass? = null
 
+        val grpcAnnotation = service.getAnnotation(ctx.grpcAnnotation.owner.kotlinFqName)
+        val protoPackage = grpcAnnotation?.arguments?.getOrNull(0)?.asConstString() ?: ""
+
         val declarations = service.declarations.memoryOptimizedMap { declaration ->
             when (declaration) {
                 is IrSimpleFunction -> {
@@ -75,6 +83,7 @@ internal object RpcDeclarationScanner {
             service = service,
             stubClass = stubClassNotNull,
             methods = declarations.filterNotNull(),
+            protoPackage = protoPackage.trim()
         )
     }
 }
@@ -87,3 +96,7 @@ private fun unsupportedDeclaration(service: IrClass, declaration: IrDeclaration,
 
     return null
 }
+
+fun IrExpression.asConstString(): String =
+    (this as? IrConst)?.takeIf { it.kind == IrConstKind.String }?.value as? String
+        ?: error("Expected IrConst of kind String, got ${dumpKotlinLike()}")

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

@@ -64,6 +64,10 @@ internal class RpcIrContext(
         getRpcIrClassSymbol("RpcServiceDescriptor", "descriptor")
     }
 
+    val grpcAnnotation by lazy {
+        getIrClassSymbol("kotlinx.rpc.grpc.annotations", "Grpc")
+    }
+
     val grpcServiceDescriptor by lazy {
         getIrClassSymbol("kotlinx.rpc.grpc.descriptor", "GrpcServiceDescriptor")
     }

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

@@ -35,6 +35,8 @@ private object Stub {
 private object Descriptor {
     const val CALLABLE_MAP = "callableMap"
     const val CALLABLES = "callables"
+
+    // the kotlin class name (derived from java_package and name)
     const val FQ_NAME = "fqName"
     const val SIMPLE_NAME = "simpleName"
     const val GET_CALLABLE = "getCallable"
@@ -1102,7 +1104,7 @@ internal class RpcStubGenerator(
         }.apply {
             arguments {
                 values {
-                    +stringConst(declaration.fqName)
+                    +stringConst(declaration.serviceFqName)
 
                     +irCallProperty(
                         receiver = IrGetValueImpl(
@@ -1127,7 +1129,7 @@ internal class RpcStubGenerator(
      * // In scope: resolver: MessageCodecResolver
      *
      * methodDescriptor<<request-type>, <response-type>>(
-     *     fullMethodName = "${descriptor.fqName}/${callable.name}",
+     *     fullMethodName = "${descriptor.serviceFqName}/${callable.name}",
      *     requestCodec = <request-codec>,
      *     responseCodec = <response-codec>,
      *     type = MethodType.<method-type>,
@@ -1182,7 +1184,7 @@ internal class RpcStubGenerator(
 
                 values {
                     // fullMethodName
-                    +stringConst("${declaration.fqName}/${callable.name}")
+                    +stringConst("${declaration.serviceFqName}/${callable.name}")
 
                     // requestCodec
                     +irCodec(requestType, resolver)

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

@@ -17,12 +17,15 @@ class ServiceDeclaration(
     val service: IrClass,
     val stubClass: IrClass,
     val methods: List<Method>,
+    val protoPackage: String,
 ) {
     // todo change to extension after KRPC-178
     val isGrpc = service.hasAnnotation(RpcClassId.grpcAnnotation)
     val simpleName = service.kotlinFqName.shortName().asString()
     val fqName = service.kotlinFqName.asString()
 
+    // the name of the service based on the proto file (or @Grpc annotation)
+    val serviceFqName = if (protoPackage.isNotEmpty()) "$protoPackage.$simpleName" else simpleName
     val serviceType = service.defaultType
 
     sealed interface Callable {

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

@@ -10,6 +10,7 @@ import kotlinx.rpc.codegen.checkers.util.functionParametersRecursionCheck
 import kotlinx.rpc.codegen.common.RpcClassId
 import kotlinx.rpc.codegen.vsApi
 import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.descriptors.isAnnotationClass
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactory0
 import org.jetbrains.kotlin.diagnostics.reportOn
@@ -26,7 +27,10 @@ object FirRpcStrictModeClassChecker {
         context: CheckerContext,
         reporter: DiagnosticReporter,
     ) {
-        if (!context.session.predicateBasedProvider.matches(FirRpcPredicates.rpc, declaration)) {
+        if (!context.session.predicateBasedProvider.matches(FirRpcPredicates.rpc, declaration)
+            // skip checks for annotation classes
+            || declaration.classKind.isAnnotationClass
+        ) {
             return
         }
 
@@ -37,7 +41,10 @@ object FirRpcStrictModeClassChecker {
                 }
 
                 is FirNamedFunctionSymbol -> {
-                    fun reportOn(element: KtSourceElement?, checker: FirRpcStrictModeDiagnostics.() -> KtDiagnosticFactory0) {
+                    fun reportOn(
+                        element: KtSourceElement?,
+                        checker: FirRpcStrictModeDiagnostics.() -> KtDiagnosticFactory0,
+                    ) {
                         reporter.reportOn(element, FirRpcStrictModeDiagnostics.checker(), context)
                     }
 

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/annotations/Grpc.kt

@@ -5,11 +5,10 @@
 package kotlinx.rpc.grpc.annotations
 
 import kotlinx.rpc.annotations.Rpc
-import kotlinx.rpc.internal.utils.InternalRpcApi
 
 /**
  * Annotation used for marking gRPC services.
  */
 @Target(AnnotationTarget.CLASS, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.TYPE_PARAMETER)
 @Rpc
-public annotation class Grpc
+public annotation class Grpc(val protoPackage: String = "")

protoc-gen/grpc/src/main/kotlin/kotlinx/rpc/protoc/gen/grpc/ModelToGrpcKotlinCommonGenerator.kt

@@ -28,10 +28,13 @@ class ModelToGrpcKotlinCommonGenerator(
 
     @Suppress("detekt.LongMethod")
     private fun CodeGenerator.generatePublicService(service: ServiceDeclaration) {
+        val pkg = service.dec.file.`package`.orEmpty()
+        val annotationParams = if (pkg.isNotEmpty()) """(protoPackage = "$pkg")""" else ""
+
         clazz(
             name = service.name.simpleName,
             declarationType = CodeGenerator.DeclarationType.Interface,
-            annotations = listOf("@kotlinx.rpc.grpc.annotations.Grpc")
+            annotations = listOf("@kotlinx.rpc.grpc.annotations.Grpc$annotationParams")
         ) {
             service.methods.forEach { method ->
                 val inputType = method.inputType

tests/compiler-plugin-tests/src/main/kotlin/kotlinx/rpc/codegen/test/Grpc.kt

@@ -18,6 +18,7 @@ import kotlin.reflect.KType
  * To check in methods:
  * ```
  * bareMethodName
+ * fullMethodName
  * type
  * serviceName
  * isSafe
@@ -43,6 +44,7 @@ inline fun <@Grpc reified T : Any> grpcDelegate(): GrpcServiceDelegate {
 
 fun MethodDescriptor<*, *>.checkMethod(
     expectedMethodName: String,
+    expectedFullMethodName: String,
     expectedMethodType: MethodDescriptor.MethodType,
     expectedServiceName: String,
     expectedIsSafe: Boolean = true,
@@ -51,6 +53,7 @@ fun MethodDescriptor<*, *>.checkMethod(
 ): String? {
     return when {
         bareMethodName != expectedMethodName -> "wrong bareMethodName: $bareMethodName"
+        fullMethodName != expectedFullMethodName -> "wrong bareMethodName: $fullMethodName"
         type != expectedMethodType -> "wrong type: $type"
         serviceName != expectedServiceName -> "wrong service name: $fullMethodName"
         isSafe != expectedIsSafe -> "wrong isSafe: $isSafe"