Fix compilation

Author: Mr3zee

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

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.ir.builders.declarations.IrFieldBuilder
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrCall
-import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl

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

@@ -4,14 +4,11 @@
 
 package kotlinx.rpc.codegen.extension
 
-import kotlinx.rpc.codegen.VersionSpecificApi
 import kotlinx.rpc.codegen.common.RpcNames
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.fir.java.enhancement.FirEmptyJavaDeclarationList.declarations
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
-import org.jetbrains.kotlin.ir.declarations.IrParameterKind
 import org.jetbrains.kotlin.ir.declarations.IrProperty
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.types.classOrNull

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

@@ -7,7 +7,6 @@ package kotlinx.rpc.codegen.extension
 import kotlinx.rpc.codegen.VersionSpecificApi
 import kotlinx.rpc.codegen.common.rpcMethodClassName
 import org.jetbrains.kotlin.backend.common.lower.DeclarationIrBuilder
-import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionBase
 import org.jetbrains.kotlin.backend.jvm.functionByName
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities

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

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.declaredFunctions
 import org.jetbrains.kotlin.fir.declarations.utils.isInterface
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.extensions.*
@@ -259,7 +258,7 @@ class FirRpcServiceGenerator(
      * Scrapes the functions from the [owner] to generate method classes.
      */
     private fun generateRpcServiceStubClass(owner: FirClassSymbol<*>): FirRegularClassSymbol? {
-        val functions = owner.declaredFunctions(session)
+        val functions = vsApi { owner.declaredFunctionsVS(session) }
 
         return createNestedClass(owner, RpcNames.SERVICE_STUB_NAME, RpcGeneratedStubKey(owner.name, functions)) {
             visibility = Visibilities.Public

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

@@ -6,7 +6,15 @@ package kotlinx.rpc.codegen
 
 import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -23,6 +31,14 @@ interface FirVersionSpecificApi {
     ): FirClassSymbol<*>?
 
     var FirResolvedTypeRefBuilder.coneTypeVS: ConeKotlinType
+
+    fun FirClassSymbol<*>.declaredFunctionsVS(session: FirSession): List<FirFunctionSymbol<*>>
+
+    fun FirRegularClassSymbol.constructorsVS(session: FirSession): List<FirConstructorSymbol>
+
+    fun FirRegularClass.declarationsVS(session: FirSession): List<FirBasedSymbol<*>>
+
+    val FirResolvedTypeRef.coneTypeVS: ConeKotlinType
 }
 
 inline fun <T> vsApi(body: FirVersionSpecificApi.() -> T): T {

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.processAllDeclarations
 import org.jetbrains.kotlin.fir.declarations.utils.isSuspend
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -37,14 +36,11 @@ object FirRpcServiceDeclarationChecker {
             )
         }
 
-        val functions = mutableListOf<FirNamedFunctionSymbol>()
-        declaration.processAllDeclarations(context.session) { symbol ->
-            if (symbol is FirNamedFunctionSymbol) {
-                functions.add(symbol)
-            }
-        }
-
-        functions.onEach { function ->
+        vsApi {
+            declaration
+                .declarationsVS(context.session)
+                .filterIsInstance<FirNamedFunctionSymbol>()
+        }.onEach { function ->
             if (function.typeParameterSymbols.isNotEmpty()) {
                 reporter.reportOn(
                     source = function.source,
@@ -53,7 +49,7 @@ object FirRpcServiceDeclarationChecker {
                 )
             }
 
-            val returnType = vsApi { function.resolvedReturnTypeRef.coneType.toClassSymbolVS(context.session) }
+            val returnType = vsApi { function.resolvedReturnTypeRef.coneTypeVS.toClassSymbolVS(context.session) }
                 ?: return@onEach
 
             if (returnType.classId != RpcClassId.flow && !function.isSuspend) {

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

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.extractArgumentsTypeRefAndSource
 import org.jetbrains.kotlin.fir.analysis.checkers.toClassLikeSymbol
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.processAllDeclarations
 import org.jetbrains.kotlin.fir.declarations.utils.isSuspend
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
@@ -70,7 +69,7 @@ object FirRpcStrictModeClassChecker {
         }
 
         val serializablePropertiesProvider = context.session.serializablePropertiesProvider
-        declaration.processAllDeclarations(context.session) { declaration ->
+        vsApi { declaration.declarationsVS(context.session) }.forEach { declaration ->
             when (declaration) {
                 is FirPropertySymbol -> {
                     ctx.strictModeDiagnostics.FIELD_IN_RPC_SERVICE?.let {
@@ -99,7 +98,7 @@ object FirRpcStrictModeClassChecker {
         }
 
         val returnClassSymbol = vsApi {
-            function.resolvedReturnTypeRef.coneType.toClassSymbolVS(context.session)
+            function.resolvedReturnTypeRef.coneTypeVS.toClassSymbolVS(context.session)
         }
 
         val types = function.valueParameterSymbols.memoryOptimizedMap { parameter ->
@@ -168,7 +167,7 @@ object FirRpcStrictModeClassChecker {
             }
 
         val flowProps: List<FirTypeRef> = if (symbol.classId == RpcClassId.flow) {
-            listOf<FirTypeRef>(extracted.values.toList()[0]!!)
+            listOf(extracted.values.toList()[0]!!)
         } else {
             emptyList()
         }

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

@@ -7,7 +7,6 @@ package kotlinx.rpc.codegen.serialization
 import kotlinx.rpc.codegen.vsApi
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.constructors
 import org.jetbrains.kotlin.fir.expressions.buildResolvedArgumentList
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationCall
 import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
@@ -23,9 +22,11 @@ fun FirAnnotationContainer.addAnnotation(annotationId: ClassId, session: FirSess
         .getClassLikeSymbolByClassId(annotationId)
             as? FirRegularClassSymbol ?: return
 
-    val annotationConstructor = annotation
-        .constructors(session)
-        .firstOrNull() ?: return
+    val annotationConstructor = vsApi {
+        annotation
+            .constructorsVS(session)
+            .firstOrNull() ?: return
+    }
 
     val annotationCall = buildAnnotationCall {
         argumentList = buildResolvedArgumentList(null, linkedMapOf())

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

@@ -6,8 +6,15 @@ package kotlinx.rpc.codegen
 
 import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.resolve.toClassSymbol
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.toFirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
@@ -32,4 +39,21 @@ object FirVersionSpecificApiImpl : FirVersionSpecificApi {
         set(value) {
             coneType = value
         }
+
+    override fun FirClassSymbol<*>.declaredFunctionsVS(session: FirSession): List<FirFunctionSymbol<FirFunction>> {
+        @OptIn(SymbolInternals::class)
+        return fir.declarations
+            .filterIsInstance<FirFunction>()
+            .map { it.symbol }
+    }
+
+    override fun FirRegularClassSymbol.constructorsVS(session: FirSession): List<FirConstructorSymbol> {
+        return declarationSymbols.filterIsInstance<FirConstructorSymbol>()
+    }
+
+    override fun FirRegularClass.declarationsVS(session: FirSession): List<FirBasedSymbol<*>> {
+        return declarations.map { it.symbol }
+    }
+
+    override val FirResolvedTypeRef.coneTypeVS: ConeKotlinType get() = coneType
 }

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

@@ -30,37 +30,37 @@ class FirCheckedAnnotationFunctionCallCheckerVS(
 class FirCheckedAnnotationTypeParameterCheckerVS(
     private val ctx: FirCheckersContext,
 ) : FirTypeParameterChecker(MppCheckerKind.Common) {
-    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirTypeParameter, context: CheckerContext, reporter: DiagnosticReporter) {
         FirCheckedAnnotationTypeParameterChecker.check(ctx, declaration, context, reporter)
     }
 }
 
 class FirCheckedAnnotationFirClassCheckerVS(
     private val ctx: FirCheckersContext,
 ) : FirClassChecker(MppCheckerKind.Common) {
-    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
         FirCheckedAnnotationFirClassChecker.check(ctx, declaration, context, reporter)
     }
 }
 
 class FirCheckedAnnotationFirFunctionCheckerVS(
     private val ctx: FirCheckersContext,
 ) : FirFunctionChecker(MppCheckerKind.Common) {
-    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
         FirCheckedAnnotationFirFunctionChecker.check(ctx, declaration, context, reporter)
     }
 }
 
 class FirRpcAnnotationCheckerVS(private val ctx: FirCheckersContext) : FirRegularClassChecker(MppCheckerKind.Common) {
-    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
         FirRpcAnnotationChecker.check(ctx, declaration, context, reporter)
     }
 }
 
 class FirRpcServiceDeclarationCheckerVS(
     private val ctx: FirCheckersContext,
 ) : FirRegularClassChecker(MppCheckerKind.Common) {
-    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
         FirRpcServiceDeclarationChecker.check(ctx, declaration, context, reporter)
     }
 }
@@ -74,7 +74,7 @@ class FirRpcStrictModeExpressionCheckerVS(
 }
 
 class FirRpcStrictModeClassCheckerVS(private val ctx: FirCheckersContext) : FirRegularClassChecker(MppCheckerKind.Common) {
-    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
         FirRpcStrictModeClassChecker.check(ctx, declaration, context, reporter)
     }
 }