Api naming (#236)

Author: Mr3zee

CONTRIBUTING.md

@@ -102,7 +102,7 @@ A few things to remember:
 * Every public API (including functions, classes, objects and so on) should be documented,
   every parameter, property, return types and exceptions should be described properly.
 * A Public API that is not intended to be used by end-users that couldn't be made private/internal due to technical reasons,
-  should be marked with `@InternalRPCApi` annotation.
+  should be marked with `@InternalRpcApi` annotation.
 
 ### Commit messages
 

README.md

@@ -44,7 +44,7 @@ Then, choose how do you want your service to communicate. For example, you can u
 ```kotlin
 fun main() {
     embeddedServer(Netty, 8080) {
-        install(RPC)
+        install(Krpc)
         routing {
             rpc("/awesome") {
                 rpcConfig {
@@ -61,7 +61,7 @@ fun main() {
 ```
 To connect to the server use the following [Ktor Client](https://ktor.io/docs/create-client.html) setup:
 ```kotlin
-val rpcClient = HttpClient { installRPC() }.rpc {
+val rpcClient = HttpClient { installKrpc() }.rpc {
     url("ws://localhost:8080/awesome")
 
     rpcConfig {

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

@@ -16,13 +16,13 @@ import org.jetbrains.kotlin.ir.util.dumpKotlinLike
 
 /**
  * This class scans user declared RPC service
- * and returns all necessary information for code generation by [RPCStubGenerator].
+ * and returns all necessary information for code generation by [RpcStubGenerator].
  *
  * Some checks are preformed during scanning,
  * but all user-friendly errors are expected to be thrown by frontend plugins
  */
-internal object RPCDeclarationScanner {
-    fun scanServiceDeclaration(service: IrClass, ctx: RPCIrContext, logger: MessageCollector): ServiceDeclaration {
+internal object RpcDeclarationScanner {
+    fun scanServiceDeclaration(service: IrClass, ctx: RpcIrContext, logger: MessageCollector): ServiceDeclaration {
         var stubClass: IrClass? = null
 
         val declarations = service.declarations.memoryOptimizedMap { declaration ->

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

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.ir.util.properties
 import org.jetbrains.kotlin.platform.konan.isNative
 import org.jetbrains.kotlin.types.Variance
 
-internal class RPCIrContext(
+internal class RpcIrContext(
     val pluginContext: IrPluginContext,
     val versionSpecificApi: VersionSpecificApi,
 ) {
@@ -98,7 +98,7 @@ internal class RPCIrContext(
     }
 
     val rpcEagerFieldAnnotation by lazy {
-        getRpcIrClassSymbol("RPCEagerField")
+        getRpcIrClassSymbol("RpcEagerField")
     }
 
     val rpcServiceDescriptor by lazy {
@@ -200,7 +200,7 @@ internal class RPCIrContext(
 
         val lazyGetValue by lazy {
             namedFunction("kotlin", "getValue") {
-                it.owner.extensionReceiverParameter?.type?.classOrNull == this@RPCIrContext.lazy
+                it.owner.extensionReceiverParameter?.type?.classOrNull == this@RpcIrContext.lazy
             }
         }
 

compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RPCIrExtension.kt renamed to compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcIrExtension.kt

@@ -11,16 +11,16 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 
-class RPCIrExtension(configuration: CompilerConfiguration) : IrGenerationExtension {
+class RpcIrExtension(configuration: CompilerConfiguration) : IrGenerationExtension {
     private val logger = configuration.get(VersionSpecificApi.INSTANCE.messageCollectorKey, MessageCollector.NONE)
 
     override fun generate(
         moduleFragment: IrModuleFragment,
         pluginContext: IrPluginContext,
     ) {
-        val context = RPCIrContext(pluginContext, VersionSpecificApi.INSTANCE)
+        val context = RpcIrContext(pluginContext, VersionSpecificApi.INSTANCE)
 
-        val processor = RPCIrServiceProcessor(logger)
+        val processor = RpcIrServiceProcessor(logger)
         moduleFragment.transform(processor, context)
     }
 }

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

@@ -11,20 +11,20 @@ import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.util.hasAnnotation
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 
-internal class RPCIrServiceProcessor(
+internal class RpcIrServiceProcessor(
     @Suppress("unused")
     private val logger: MessageCollector,
-) : IrElementTransformer<RPCIrContext> {
-    override fun visitClass(declaration: IrClass, data: RPCIrContext): IrStatement {
+) : IrElementTransformer<RpcIrContext> {
+    override fun visitClass(declaration: IrClass, data: RpcIrContext): IrStatement {
         if (declaration.hasAnnotation(RpcClassId.rpcAnnotation)) {
             processService(declaration, data)
         }
 
         return super.visitClass(declaration, data)
     }
 
-    private fun processService(service: IrClass, context: RPCIrContext) {
-        val declaration = RPCDeclarationScanner.scanServiceDeclaration(service, context, logger)
-        RPCStubGenerator(declaration, context, logger).generate()
+    private fun processService(service: IrClass, context: RpcIrContext) {
+        val declaration = RpcDeclarationScanner.scanServiceDeclaration(service, context, logger)
+        RpcStubGenerator(declaration, context, logger).generate()
     }
 }

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

@@ -45,9 +45,9 @@ private object Descriptor {
 }
 
 @Suppress("detekt.LargeClass", "detekt.TooManyFunctions")
-internal class RPCStubGenerator(
+internal class RpcStubGenerator(
     private val declaration: ServiceDeclaration,
-    private val ctx: RPCIrContext,
+    private val ctx: RpcIrContext,
     @Suppress("unused")
     private val logger: MessageCollector,
 ) {
@@ -253,7 +253,7 @@ internal class RPCStubGenerator(
 
     /**
      * RPC fields.
-     * Can be of two kinds: Lazy and Eager (defined by `@RPCEagerField` annotation)
+     * Can be of two kinds: Lazy and Eager (defined by `@RpcEagerField` annotation)
      *
      * Lazy:
      * ``` kotlin
@@ -623,15 +623,15 @@ internal class RPCStubGenerator(
      * ```
      *
      * This method generates missing getters and backing fields' values.
-     * And adds RPCMethodClassArguments supertype with `asArray` method implemented.
+     * And adds RpcMethodClassArguments supertype with `asArray` method implemented.
      *
      * Resulting class:
      * ```kotlin
      * @Serializable
      * class hello$rpcMethod(
      *    val arg1: String,
      *    val arg2: Int,
-     * ) : RPCMethodClassArguments {
+     * ) : RpcMethodClassArguments {
      *    // or emptyArray when no arguments
      *    override fun asArray(): Array<Any?> = arrayOf(arg1, arg2)
      * }

compiler-plugin/compiler-plugin-cli/src/main-resources/latest/META-INF/services/org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor

@@ -2,4 +2,4 @@
 # Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
 #
 
-kotlinx.rpc.codegen.RPCCommandLineProcessor
+kotlinx.rpc.codegen.RpcCommandLineProcessor

compiler-plugin/compiler-plugin-cli/src/main-resources/latest/META-INF/services/org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar

@@ -2,4 +2,4 @@
 # Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
 #
 
-kotlinx.rpc.codegen.RPCCompilerPlugin
+kotlinx.rpc.codegen.RpcCompilerPlugin

compiler-plugin/compiler-plugin-cli/src/main/latest/kotlinx/rpc/codegen/RPCCompilerPlugin.kt renamed to compiler-plugin/compiler-plugin-cli/src/main/latest/kotlinx/rpc/codegen/RpcCompilerPlugin.kt

@@ -4,7 +4,7 @@
 
 package kotlinx.rpc.codegen
 
-import kotlinx.rpc.codegen.extension.RPCIrExtension
+import kotlinx.rpc.codegen.extension.RpcIrExtension
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.compiler.plugin.CliOption
 import org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor
@@ -14,14 +14,14 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
 
 @OptIn(ExperimentalCompilerApi::class)
-class RPCCommandLineProcessor : CommandLineProcessor {
+class RpcCommandLineProcessor : CommandLineProcessor {
     override val pluginId = "kotlinx.rpc.compiler-plugin"
 
     override val pluginOptions = emptyList<CliOption>()
 }
 
 @OptIn(ExperimentalCompilerApi::class)
-class RPCCompilerPlugin : CompilerPluginRegistrar() {
+class RpcCompilerPlugin : CompilerPluginRegistrar() {
     override val supportsK2: Boolean = true
 
     override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
@@ -33,6 +33,6 @@ class RPCCompilerPlugin : CompilerPluginRegistrar() {
 fun CompilerPluginRegistrar.ExtensionStorage.registerRpcExtensions(configuration: CompilerConfiguration) {
     VersionSpecificApi.INSTANCE = VersionSpecificApiImpl
 
-    IrGenerationExtension.registerExtension(RPCIrExtension(configuration))
+    IrGenerationExtension.registerExtension(RpcIrExtension(configuration))
     FirExtensionRegistrarAdapter.registerExtension(FirRpcExtensionRegistrar(configuration))
 }