diff --git a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/VersionSpecificApi.kt b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/VersionSpecificApi.kt index 52c7542cc..dcd7ccc00 100644 --- a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/VersionSpecificApi.kt +++ b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/VersionSpecificApi.kt @@ -6,6 +6,7 @@ package kotlinx.rpc.codegen +import kotlinx.rpc.codegen.extension.IrMemberAccessExpressionData import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext import org.jetbrains.kotlin.cli.common.messages.MessageCollector import org.jetbrains.kotlin.config.CompilerConfigurationKey @@ -13,6 +14,7 @@ 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.IrMemberAccessExpression import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl @@ -79,6 +81,12 @@ interface VersionSpecificApi { origin: IrStatementOrigin? = null, source: SourceElement = SourceElement.NO_SOURCE, ): IrConstructorCallImpl + + fun IrFunction.valueParametersVS(): List + val IrFunction.extensionReceiverParameterVS: IrValueParameter? + var IrFunction.dispatchReceiverParameterVS: IrValueParameter? + + fun IrMemberAccessExpressionData.buildFor(access: IrMemberAccessExpression<*>) } @Suppress("unused") diff --git a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/IrMemberAccessExpressionBuilder.kt b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/IrMemberAccessExpressionBuilder.kt new file mode 100644 index 000000000..1595b8592 --- /dev/null +++ b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/IrMemberAccessExpressionBuilder.kt @@ -0,0 +1,64 @@ +/* + * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. + */ + +package kotlinx.rpc.codegen.extension + +import kotlinx.rpc.codegen.VersionSpecificApi +import org.jetbrains.kotlin.ir.expressions.IrExpression +import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression +import org.jetbrains.kotlin.ir.types.IrType + +class IrMemberAccessExpressionData( + val dispatchReceiver: IrExpression?, + val extensionReceiver: IrExpression?, + val typeArguments: List, + val valueArguments: List, +) + +class IrMemberAccessExpressionBuilder(private val vsApi: VersionSpecificApi) { + var dispatchReceiver: IrExpression? = null + var extensionReceiver: IrExpression? = null + + private var valueArguments: List = emptyList() + private var typeArguments: List = emptyList() + + val typeBuilder = TypeBuilder() + + fun types(builder: TypeBuilder.() -> Unit) { + typeBuilder.builder() + } + + val valueBuilder = ValueBuilder() + + fun values(builder: ValueBuilder.() -> Unit) { + valueBuilder.builder() + } + + inner class TypeBuilder { + operator fun IrType.unaryPlus() { + typeArguments += this + } + } + + inner class ValueBuilder { + operator fun IrExpression.unaryPlus() { + valueArguments += this + } + } + + fun build(): IrMemberAccessExpressionData = IrMemberAccessExpressionData( + dispatchReceiver, + extensionReceiver, + typeArguments, + valueArguments + ) +} + +inline fun IrMemberAccessExpression<*>.arguments(vsApi: VersionSpecificApi, builder: IrMemberAccessExpressionBuilder.() -> Unit) { + IrMemberAccessExpressionBuilder(vsApi).apply(builder).build().let { data -> + with(vsApi) { + data.buildFor(this@arguments) + } + } +} diff --git a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/IrUtils.kt b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/IrUtils.kt index bd777f55e..648c2eca2 100644 --- a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/IrUtils.kt +++ b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/IrUtils.kt @@ -23,10 +23,6 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance import java.util.* -fun String.capitalized(): String { - return replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() } -} - fun IrClassifierSymbol.typeWith(type: IrType, variance: Variance): IrType { return IrSimpleTypeImpl( classifier = this, diff --git a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcDeclarationScanner.kt b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcDeclarationScanner.kt index 3f1766b60..3061edb0d 100644 --- a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcDeclarationScanner.kt +++ b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcDeclarationScanner.kt @@ -34,8 +34,10 @@ internal object RpcDeclarationScanner { ServiceDeclaration.Method( function = declaration, - arguments = declaration.valueParameters.memoryOptimizedMap { param -> - ServiceDeclaration.Method.Argument(param, param.type) + arguments = ctx.versionSpecificApi.run { + declaration.valueParametersVS().memoryOptimizedMap { param -> + ServiceDeclaration.Method.Argument(param, param.type) + } }, ) } diff --git a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcIrContext.kt b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcIrContext.kt index 8763b4fc6..9ba01c84f 100644 --- a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcIrContext.kt +++ b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcIrContext.kt @@ -202,19 +202,25 @@ internal class RpcIrContext( val lazy by lazy { namedFunction("kotlin", "lazy") { - it.owner.valueParameters.size == 1 + vsApi { + it.owner.valueParametersVS().size == 1 + } } } val lazyGetValue by lazy { namedFunction("kotlin", "getValue") { - it.owner.extensionReceiverParameter?.type?.classOrNull == this@RpcIrContext.lazy + vsApi { + it.owner.extensionReceiverParameterVS?.type?.classOrNull == this@RpcIrContext.lazy + } } } val listOf by lazy { namedFunction("kotlin.collections", "listOf") { - it.owner.valueParameters.singleOrNull()?.isVararg ?: false + vsApi { + it.owner.valueParametersVS().singleOrNull()?.isVararg ?: false + } } } @@ -224,7 +230,9 @@ internal class RpcIrContext( val mapOf by lazy { namedFunction("kotlin.collections", "mapOf") { - it.owner.valueParameters.singleOrNull()?.isVararg ?: false + vsApi { + it.owner.valueParametersVS().singleOrNull()?.isVararg ?: false + } } } @@ -284,4 +292,8 @@ internal class RpcIrContext( return versionSpecificApi.referenceClass(pluginContext, packageName, name) ?: error("Unable to find symbol. Package: $packageName, name: $name") } + + private fun vsApi(body: VersionSpecificApi.() -> T): T { + return versionSpecificApi.run(body) + } } diff --git a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcStubGenerator.kt b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcStubGenerator.kt index 661245317..fd46efe84 100644 --- a/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcStubGenerator.kt +++ b/compiler-plugin/compiler-plugin-backend/src/main/core/kotlinx/rpc/codegen/extension/RpcStubGenerator.kt @@ -5,7 +5,6 @@ package kotlinx.rpc.codegen.extension import kotlinx.rpc.codegen.VersionSpecificApi -import kotlinx.rpc.codegen.VersionSpecificApiImpl.copyToVS import kotlinx.rpc.codegen.common.rpcMethodClassName import org.jetbrains.kotlin.backend.common.lower.DeclarationIrBuilder import org.jetbrains.kotlin.backend.jvm.functionByName @@ -232,9 +231,13 @@ internal class RpcStubGenerator( typeArgumentsCount = 0, ) }.apply { - dispatchReceiver = irCallProperty(stubClass, clientProperty) + arguments { + dispatchReceiver = irCallProperty(stubClass, clientProperty) - putValueArgument(0, irCallProperty(stubClass, stubIdProperty)) + values { + +irCallProperty(stubClass, stubIdProperty) + } + } } ) } @@ -324,24 +327,28 @@ internal class RpcStubGenerator( valueArgumentsCount = 4, ) }.apply { - extensionReceiver = irCallProperty(stubClass, clientProperty) - putTypeArgument(0, fieldTypeParameter.typeOrFail) + arguments { + extensionReceiver = irCallProperty(stubClass, clientProperty) - putValueArgument( - index = 0, - valueArgument = IrGetValueImpl( - startOffset = UNDEFINED_OFFSET, - endOffset = UNDEFINED_OFFSET, - type = ctx.coroutineScope.defaultType, - symbol = stubClassThisReceiver.symbol, - ), - ) + types { + +fieldTypeParameter.typeOrFail + } + + values { + +IrGetValueImpl( + startOffset = UNDEFINED_OFFSET, + endOffset = UNDEFINED_OFFSET, + type = ctx.coroutineScope.defaultType, + symbol = stubClassThisReceiver.symbol, + ) - putValueArgument(1, irGetDescriptor()) + +irGetDescriptor() - putValueArgument(2, stringConst(field.property.name.asString())) + +stringConst(field.property.name.asString()) - putValueArgument(3, irCallProperty(stubClass, stubIdProperty)) + +irCallProperty(stubClass, stubIdProperty) + } + } } if (!isLazy) { @@ -382,8 +389,6 @@ internal class RpcStubGenerator( valueArgumentsCount = 1, ) }.apply { - putTypeArgument(0, fieldType) - val lambdaType = ctx.function0.typeWith(fieldType) val lambdaFunction = factory.buildFun { @@ -407,7 +412,15 @@ internal class RpcStubGenerator( function = lambdaFunction, ) - putValueArgument(0, lambda) + arguments { + types { + +fieldType + } + + values { + +lambda + } + } } ) } @@ -425,7 +438,9 @@ internal class RpcStubGenerator( val getterThisReceiver = vsApi { stubClassThisReceiver.copyToVS(propertyGetter, origin = IrDeclarationOrigin.DEFINED) }.also { - dispatchReceiverParameter = it + vsApi { + dispatchReceiverParameterVS = it + } } body = irBuilder(symbol).irBlockBody { @@ -435,45 +450,45 @@ internal class RpcStubGenerator( callee = ctx.functions.lazyGetValue, typeArgumentsCount = 1, ).apply { - putTypeArgument(0, fieldType) - - extensionReceiver = IrGetFieldImpl( - startOffset = UNDEFINED_OFFSET, - endOffset = UNDEFINED_OFFSET, - symbol = lazyField.symbol, - type = lazyFieldType, - receiver = IrGetValueImpl( - startOffset = UNDEFINED_OFFSET, - endOffset = UNDEFINED_OFFSET, - type = stubClass.defaultType, - symbol = getterThisReceiver.symbol, - ), - ) + arguments { + types { + +fieldType + } - putValueArgument( - index = 0, - valueArgument = IrGetValueImpl( + extensionReceiver = IrGetFieldImpl( startOffset = UNDEFINED_OFFSET, endOffset = UNDEFINED_OFFSET, - type = stubClass.defaultType, - symbol = getterThisReceiver.symbol, + symbol = lazyField.symbol, + type = lazyFieldType, + receiver = IrGetValueImpl( + startOffset = UNDEFINED_OFFSET, + endOffset = UNDEFINED_OFFSET, + type = stubClass.defaultType, + symbol = getterThisReceiver.symbol, + ), ) - ) - putValueArgument( - index = 1, - valueArgument = IrPropertyReferenceImpl( - startOffset = UNDEFINED_OFFSET, - endOffset = UNDEFINED_OFFSET, - type = ctx.kProperty1.typeWith(stubClass.defaultType, fieldType), - symbol = fieldProperty.symbol, - typeArgumentsCount = 0, - field = null, - getter = propertyGetter.symbol, - setter = null, - origin = IrStatementOrigin.PROPERTY_REFERENCE_FOR_DELEGATE, - ) - ) + values { + +IrGetValueImpl( + startOffset = UNDEFINED_OFFSET, + endOffset = UNDEFINED_OFFSET, + type = stubClass.defaultType, + symbol = getterThisReceiver.symbol, + ) + + +IrPropertyReferenceImpl( + startOffset = UNDEFINED_OFFSET, + endOffset = UNDEFINED_OFFSET, + type = ctx.kProperty1.typeWith(stubClass.defaultType, fieldType), + symbol = fieldProperty.symbol, + typeArgumentsCount = 0, + field = null, + getter = propertyGetter.symbol, + setter = null, + origin = IrStatementOrigin.PROPERTY_REFERENCE_FOR_DELEGATE, + ) + } + } } ) } @@ -535,7 +550,9 @@ internal class RpcStubGenerator( val functionThisReceiver = vsApi { stubClassThisReceiver.copyToVS(this@apply, origin = IrDeclarationOrigin.DEFINED) }.also { - dispatchReceiverParameter = it + vsApi { + dispatchReceiverParameterVS = it + } } val declaredFunction = this @@ -569,10 +586,6 @@ internal class RpcStubGenerator( callee = ctx.functions.scopedClientCall, type = method.function.returnType, ).apply { - putTypeArgument(0, method.function.returnType) - - putValueArgument(0, irGet(ctx.coroutineScope.defaultType, functionThisReceiver.symbol)) - // suspend lambda // it's type is not available at runtime, but in fact exists val lambdaType = ctx.suspendFunction0.typeWith(method.function.returnType) @@ -612,7 +625,17 @@ internal class RpcStubGenerator( function = functionLambda, ) - putValueArgument(1, lambda) + arguments { + types { + +method.function.returnType + } + + values { + +irGet(ctx.coroutineScope.defaultType, functionThisReceiver.symbol) + + +lambda + } + } } ) } @@ -671,13 +694,15 @@ internal class RpcStubGenerator( // primary constructor, serialization may add another val constructor = methodClass.constructors.single { - method.arguments.size == it.valueParameters.size + vsApi { + method.arguments.size == it.valueParametersVS().size + } } vsApi { constructor.isPrimaryVS = true } methodClass.addDefaultConstructor(constructor) - constructor.valueParameters.memoryOptimizedMap { valueParam -> + vsApi { constructor.valueParametersVS() }.memoryOptimizedMap { valueParam -> methodClass.addConstructorProperty( propertyName = valueParam.name, propertyType = valueParam.type, @@ -702,7 +727,9 @@ internal class RpcStubGenerator( val asArrayThisReceiver = vsApi { methodClassThisReceiver.copyToVS(this@apply, origin = IrDeclarationOrigin.DEFINED) }.also { - dispatchReceiverParameter = it + vsApi { + dispatchReceiverParameterVS = it + } } body = irBuilder(symbol).irBlockBody { @@ -713,9 +740,11 @@ internal class RpcStubGenerator( } val arrayOfCall = irCall(callee, type = ctx.arrayOfAnyNullable).apply arrayOfCall@{ - putTypeArgument(0, ctx.anyNullable) - if (methodClass.isObject) { + arguments { + types { +ctx.anyNullable } + } + return@arrayOfCall } @@ -726,7 +755,16 @@ internal class RpcStubGenerator( }, ) - putValueArgument(0, vararg) + arguments { + types { + +ctx.anyNullable + } + + values { + +vararg + } + } + } +irReturn(arrayOfCall) @@ -767,53 +805,64 @@ internal class RpcStubGenerator( type = method.function.returnType, typeArgumentsCount = 1, ).apply { - dispatchReceiver = irCallProperty( - clazz = stubClass, - property = clientProperty, - symbol = functionThisReceiver.symbol, - ) - - putTypeArgument(0, method.function.returnType) - val rpcCallConstructor = irCallConstructor( callee = ctx.rpcCall.constructors.single(), typeArguments = emptyList(), ).apply { - putValueArgument( - index = 0, - valueArgument = irGetDescriptor(), - ) - - putValueArgument( - index = 1, - valueArgument = stringConst(method.function.name.asString()), - ) - val dataParameter = if (isMethodObject) { irGetObject(methodClass.symbol) } else { irCallConstructor( // serialization plugin adds additional constructor with more arguments callee = methodClass.constructors.single { - it.valueParameters.size == method.arguments.size + vsApi { + it.valueParametersVS().size == method.arguments.size + } }.symbol, typeArguments = emptyList(), ).apply { - arguments.forEachIndexed { i, valueParameter -> - putValueArgument(i, irGet(valueParameter)) + arguments { + values { + arguments.forEach { valueParameter -> + +irGet(valueParameter) + } + } } } } - putValueArgument(2, dataParameter) + arguments { + values { + +irGetDescriptor() - putValueArgument( - index = 3, - valueArgument = irCallProperty(stubClass, stubIdProperty, symbol = functionThisReceiver.symbol), - ) + +stringConst(method.function.name.asString()) + + +dataParameter + + +irCallProperty( + clazz = stubClass, + property = stubIdProperty, + symbol = functionThisReceiver.symbol, + ) + } + } } - putValueArgument(0, rpcCallConstructor) + arguments { + dispatchReceiver = irCallProperty( + clazz = stubClass, + property = clientProperty, + symbol = functionThisReceiver.symbol, + ) + + types { + +method.function.returnType + } + + values { + +rpcCallConstructor + } + } } return call @@ -860,11 +909,13 @@ internal class RpcStubGenerator( type = getter.returnType, symbol = getter.symbol, origin = IrStatementOrigin.GET_PROPERTY, - valueArgumentsCount = getter.valueParameters.size, + valueArgumentsCount = vsApi { getter.valueParametersVS() }.size, typeArgumentsCount = getter.typeParameters.size, ) }.apply { - dispatchReceiver = receiver + arguments { + dispatchReceiver = receiver + } } } @@ -1049,35 +1100,45 @@ internal class RpcStubGenerator( val dataCasted = irTemporary( value = irCall(ctx.functions.dataCast, type = methodClass.defaultType).apply { dataParameter ?: error("unreachable") - extensionReceiver = irGet(dataParameter) - putTypeArgument(0, methodClass.defaultType) + arguments { + extensionReceiver = irGet(dataParameter) + + types { + +methodClass.defaultType + } - putValueArgument(0, stringConst(callable.name)) - putValueArgument(1, stringConst(declaration.fqName)) + values { + +stringConst(callable.name) + +stringConst(declaration.fqName) + } + } }, nameHint = "dataCasted", irType = methodClass.defaultType, ) irCall(callable.function).apply { - dispatchReceiver = irGet(serviceParameter) - - callable.arguments.forEachIndexed { i, arg -> - putValueArgument( - index = i, - valueArgument = irCallProperty( - receiver = irGet(dataCasted), - property = methodClass.properties.single { it.name == arg.value.name }, - ), - ) + arguments { + dispatchReceiver = irGet(serviceParameter) + + values { + callable.arguments.forEach { arg -> + +irCallProperty( + receiver = irGet(dataCasted), + property = methodClass.properties.single { it.name == arg.value.name }, + ) + } + } } } } is ServiceDeclaration.FlowField -> { irCall(callable.property.getterOrFail).apply { - dispatchReceiver = irGet(serviceParameter) + arguments { + dispatchReceiver = irGet(serviceParameter) + } } } } @@ -1172,10 +1233,14 @@ internal class RpcStubGenerator( typeArgumentsCount = 2, ) }.apply mapApply@{ - putTypeArgument(0, ctx.irBuiltIns.stringType) - putTypeArgument(1, rpcCallableType) - if (isEmpty) { + arguments { + types { + +ctx.irBuiltIns.stringType + +rpcCallableType + } + } + return@mapApply } @@ -1201,17 +1266,32 @@ internal class RpcStubGenerator( valueArgumentsCount = 1, ) }.apply { - putTypeArgument(0, ctx.irBuiltIns.stringType) - putTypeArgument(1, rpcCallableType) + arguments { + types { + +ctx.irBuiltIns.stringType + +rpcCallableType + } - extensionReceiver = stringConst(callable.name) + extensionReceiver = stringConst(callable.name) - putValueArgument(0, irRpcCallable(i, callable)) + values { + +irRpcCallable(i, callable) + } + } } }, ) - putValueArgument(0, vararg) + arguments { + types { + +ctx.irBuiltIns.stringType + +rpcCallableType + } + + values { + +vararg + } + } } ) } @@ -1265,15 +1345,11 @@ internal class RpcStubGenerator( }.apply { putConstructorTypeArgument(0, declaration.serviceType) - putValueArgument(0, stringConst(callable.name)) - val dataType = when (callable) { is ServiceDeclaration.Method -> methodClasses[i].defaultType is ServiceDeclaration.FlowField -> ctx.fieldDataObject.defaultType } - putValueArgument(1, irRpcTypeCall(dataType)) - val returnType = when (callable) { is ServiceDeclaration.Method -> when { callable.function.isNonSuspendingWithFlowReturn() -> { @@ -1288,13 +1364,9 @@ internal class RpcStubGenerator( is ServiceDeclaration.FlowField -> callable.property.getterOrFail.returnType } - putValueArgument(2, irRpcTypeCall(returnType)) - val invokator = invokators[callable.name] ?: error("Expected invokator for ${callable.name} in ${declaration.service.name}") - putValueArgument(3, irCallProperty(stubCompanionObject.owner, invokator)) - val parameters = (callable as? ServiceDeclaration.Method)?.arguments ?: emptyList() @@ -1319,9 +1391,11 @@ internal class RpcStubGenerator( valueArgumentsCount = if (parameters.isEmpty()) 0 else 1, ) }.apply arrayOfCall@{ - putTypeArgument(0, ctx.rpcParameter.defaultType) - if (parameters.isEmpty()) { + arguments { + types { +ctx.rpcParameter.defaultType } + } + return@arrayOfCall } @@ -1342,17 +1416,42 @@ internal class RpcStubGenerator( valueArgumentsCount = 2, ) }.apply { - putValueArgument(0, stringConst(parameter.value.name.asString())) - putValueArgument(1, irRpcTypeCall(parameter.type)) + arguments { + values { + +stringConst(parameter.value.name.asString()) + +irRpcTypeCall(parameter.type) + } + } } }, ) - putValueArgument(0, vararg) + arguments { + types { + +ctx.rpcParameter.defaultType + } + + values { + +vararg + } + } } - putValueArgument(4, arrayOfCall) - putValueArgument(5, booleanConst(callable is ServiceDeclaration.Method && !callable.function.isSuspend)) + arguments { + values { + +stringConst(callable.name) + + +irRpcTypeCall(dataType) + + +irRpcTypeCall(returnType) + + +irCallProperty(stubCompanionObject.owner, invokator) + + +arrayOfCall + + +booleanConst(callable is ServiceDeclaration.Method && !callable.function.isSuspend) + } + } } } @@ -1382,7 +1481,9 @@ internal class RpcStubGenerator( val functionThisReceiver = vsApi { stubCompanionObjectThisReceiver.copyToVS(this@apply, origin = IrDeclarationOrigin.DEFINED) }.also { - dispatchReceiverParameter = it + vsApi { + dispatchReceiverParameterVS = it + } } val parameter = addValueParameter { @@ -1395,13 +1496,17 @@ internal class RpcStubGenerator( irCall(ctx.functions.mapGet.symbol, resultType).apply { vsApi { originVS = IrStatementOrigin.GET_ARRAY_ELEMENT } - dispatchReceiver = irCallProperty( - clazz = this@generateGetCallableFunction, - property = callableMap, - symbol = functionThisReceiver.symbol, - ) + arguments { + dispatchReceiver = irCallProperty( + clazz = this@generateGetCallableFunction, + property = callableMap, + symbol = functionThisReceiver.symbol, + ) - putValueArgument(0, irGet(parameter)) + values { + +irGet(parameter) + } + } } ) } @@ -1426,8 +1531,9 @@ internal class RpcStubGenerator( }.apply { overriddenSymbols = listOf(ctx.rpcServiceDescriptor.functionByName(Descriptor.CREATE_INSTANCE)) - dispatchReceiverParameter = vsApi { - stubCompanionObjectThisReceiver.copyToVS(this@apply, origin = IrDeclarationOrigin.DEFINED) + vsApi { + dispatchReceiverParameterVS = stubCompanionObjectThisReceiver + .copyToVS(this@apply, origin = IrDeclarationOrigin.DEFINED) } val serviceId = addValueParameter { @@ -1446,8 +1552,12 @@ internal class RpcStubGenerator( callee = stubClass.constructors.single().symbol, typeArguments = emptyList(), ).apply { - putValueArgument(0, irGet(serviceId)) - putValueArgument(1, irGet(client)) + arguments { + values { + +irGet(serviceId) + +irGet(client) + } + } } ) } @@ -1482,8 +1592,9 @@ internal class RpcStubGenerator( }.apply { overriddenSymbols = listOf(ctx.rpcServiceDescriptor.functionByName(Descriptor.GET_FIELDS)) - dispatchReceiverParameter = vsApi { - stubCompanionObjectThisReceiver.copyToVS(this@apply, origin = IrDeclarationOrigin.DEFINED) + vsApi { + dispatchReceiverParameterVS = stubCompanionObjectThisReceiver + .copyToVS(this@apply, origin = IrDeclarationOrigin.DEFINED) } val service = addValueParameter { @@ -1500,9 +1611,11 @@ internal class RpcStubGenerator( callee = if (isEmpty) ctx.functions.emptyList else ctx.functions.listOf, type = anyListType, ).apply listApply@{ - putTypeArgument(0, ctx.anyNullable) - if (isEmpty) { + arguments { + types { +ctx.anyNullable } + } + return@listApply } @@ -1516,7 +1629,15 @@ internal class RpcStubGenerator( } ) - putValueArgument(0, vararg) + arguments { + types { + +ctx.anyNullable + } + + values { + +vararg + } + } } +irReturn(irAs(listCall, listType)) @@ -1547,16 +1668,17 @@ internal class RpcStubGenerator( ) }.apply { val companionObjectType = stubCompanionObject.defaultType - putValueArgument( - index = 0, - valueArgument = IrClassReferenceImpl( - startOffset = startOffset, - endOffset = endOffset, - type = ctx.irBuiltIns.kClassClass.typeWith(companionObjectType), - symbol = stubCompanionObject, - classType = companionObjectType, - ) - ) + arguments { + values { + +IrClassReferenceImpl( + startOffset = startOffset, + endOffset = endOffset, + type = ctx.irBuiltIns.kClassClass.typeWith(companionObjectType), + symbol = stubCompanionObject, + classType = companionObjectType, + ) + } + } } } @@ -1575,7 +1697,11 @@ internal class RpcStubGenerator( constructorTypeArgumentsCount = 0, ) }.apply { - putValueArgument(0, irTypeOfCall(type)) + arguments { + values { + +irTypeOfCall(type) + } + } } } @@ -1593,7 +1719,9 @@ internal class RpcStubGenerator( valueArgumentsCount = 0, ) }.apply { - putTypeArgument(0, type) + arguments { + types { +type } + } } } @@ -1629,7 +1757,9 @@ internal class RpcStubGenerator( it.name == OperatorNameConventions.EQUALS }.symbol - dispatchReceiverParameter = anyClass.copyThisReceiver(this@apply) + vsApi { + dispatchReceiverParameterVS = anyClass.copyThisReceiver(this@apply) + } addValueParameter { name = Name.identifier("other") @@ -1650,7 +1780,9 @@ internal class RpcStubGenerator( it.name == OperatorNameConventions.HASH_CODE }.symbol - dispatchReceiverParameter = anyClass.copyThisReceiver(this@apply) + vsApi { + dispatchReceiverParameterVS = anyClass.copyThisReceiver(this@apply) + } } addFunction { @@ -1666,12 +1798,15 @@ internal class RpcStubGenerator( it.name == OperatorNameConventions.TO_STRING }.symbol - dispatchReceiverParameter = anyClass.copyThisReceiver(this@apply) + vsApi { + dispatchReceiverParameterVS = anyClass.copyThisReceiver(this@apply) + } } } - private fun IrClass.copyThisReceiver(function: IrFunction) = + private fun IrClass.copyThisReceiver(function: IrFunction) = vsApi { thisReceiver?.copyToVS(function, origin = IrDeclarationOrigin.DEFINED) + } private fun stringConst(value: String) = IrConstImpl.string( startOffset = UNDEFINED_OFFSET, @@ -1687,7 +1822,11 @@ internal class RpcStubGenerator( value = value, ) - private fun vsApi(body: VersionSpecificApi.() -> T): T { + private inline fun vsApi(body: VersionSpecificApi.() -> T): T { return ctx.versionSpecificApi.body() } + + private inline fun IrMemberAccessExpression<*>.arguments(body: IrMemberAccessExpressionBuilder.() -> Unit) { + return arguments(ctx.versionSpecificApi, body) + } } diff --git a/compiler-plugin/compiler-plugin-backend/src/main/latest/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt b/compiler-plugin/compiler-plugin-backend/src/main/latest/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt index 141d2a3d8..05bf28a78 100644 --- a/compiler-plugin/compiler-plugin-backend/src/main/latest/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt +++ b/compiler-plugin/compiler-plugin-backend/src/main/latest/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt @@ -4,6 +4,8 @@ package kotlinx.rpc.codegen +import kotlinx.rpc.codegen.extension.IrMemberAccessExpressionData +import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext import org.jetbrains.kotlin.backend.common.ir.addExtensionReceiver import org.jetbrains.kotlin.cli.common.messages.MessageCollector @@ -133,4 +135,36 @@ object VersionSpecificApiImpl : VersionSpecificApi { source = source, ) } + + override fun IrFunction.valueParametersVS(): List { + return valueParameters + } + + override val IrFunction.extensionReceiverParameterVS: IrValueParameter? + get() = extensionReceiverParameter + + override var IrFunction.dispatchReceiverParameterVS: IrValueParameter? + get() = dispatchReceiverParameter + set(value) { + dispatchReceiverParameter = value + } + + + override fun IrMemberAccessExpressionData.buildFor(access: IrMemberAccessExpression<*>) { + if (dispatchReceiver != null) { + access.dispatchReceiver = dispatchReceiver + } + + if (extensionReceiver != null) { + access.extensionReceiver = extensionReceiver + } + + valueArguments.forEachIndexed { index, irExpression -> + access.putValueArgument(index, irExpression) + } + + typeArguments.forEachIndexed { index, irType -> + access.putTypeArgument(index, irType) + } + } } diff --git a/compiler-plugin/compiler-plugin-backend/src/main/pre_2_0_10/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt b/compiler-plugin/compiler-plugin-backend/src/main/pre_2_0_10/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt index 961f0a0d3..d574b9c9b 100644 --- a/compiler-plugin/compiler-plugin-backend/src/main/pre_2_0_10/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt +++ b/compiler-plugin/compiler-plugin-backend/src/main/pre_2_0_10/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt @@ -4,6 +4,8 @@ package kotlinx.rpc.codegen +import kotlinx.rpc.codegen.extension.IrMemberAccessExpressionData +import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext import org.jetbrains.kotlin.backend.common.ir.addExtensionReceiver import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys @@ -133,4 +135,31 @@ object VersionSpecificApiImpl : VersionSpecificApi { source = source, ) } + + override fun IrFunction.valueParametersVS(): List { + return valueParameters + } + + override val IrFunction.extensionReceiverParameterVS: IrValueParameter? + get() = extensionReceiverParameter + + override var IrFunction.dispatchReceiverParameterVS: IrValueParameter? + get() = dispatchReceiverParameter + set(value) { + dispatchReceiverParameter = value + } + + + override fun IrMemberAccessExpressionData.buildFor(access: IrMemberAccessExpression<*>) { + access.dispatchReceiver = dispatchReceiver + access.extensionReceiver = extensionReceiver + + valueArguments.forEachIndexed { index, irExpression -> + access.putValueArgument(index, irExpression) + } + + typeArguments.forEachIndexed { index, irType -> + access.putTypeArgument(index, irType) + } + } } diff --git a/compiler-plugin/compiler-plugin-backend/src/main/pre_2_0_21/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt b/compiler-plugin/compiler-plugin-backend/src/main/pre_2_0_21/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt index 8b64ec56c..8b59920e6 100644 --- a/compiler-plugin/compiler-plugin-backend/src/main/pre_2_0_21/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt +++ b/compiler-plugin/compiler-plugin-backend/src/main/pre_2_0_21/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt @@ -4,6 +4,7 @@ package kotlinx.rpc.codegen +import kotlinx.rpc.codegen.extension.IrMemberAccessExpressionData import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext import org.jetbrains.kotlin.backend.common.ir.addExtensionReceiver import org.jetbrains.kotlin.cli.common.messages.MessageCollector @@ -13,6 +14,7 @@ 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.IrMemberAccessExpression import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl @@ -133,4 +135,31 @@ object VersionSpecificApiImpl : VersionSpecificApi { source = source, ) } + + override fun IrFunction.valueParametersVS(): List { + return valueParameters + } + + override val IrFunction.extensionReceiverParameterVS: IrValueParameter? + get() = extensionReceiverParameter + + override var IrFunction.dispatchReceiverParameterVS: IrValueParameter? + get() = dispatchReceiverParameter + set(value) { + dispatchReceiverParameter = value + } + + + override fun IrMemberAccessExpressionData.buildFor(access: IrMemberAccessExpression<*>) { + access.dispatchReceiver = dispatchReceiver + access.extensionReceiver = extensionReceiver + + valueArguments.forEachIndexed { index, irExpression -> + access.putValueArgument(index, irExpression) + } + + typeArguments.forEachIndexed { index, irType -> + access.putTypeArgument(index, irType) + } + } } diff --git a/compiler-plugin/compiler-plugin-backend/src/main/v_2_2/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt b/compiler-plugin/compiler-plugin-backend/src/main/v_2_2/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt index 1f3c7ab42..852c57eef 100644 --- a/compiler-plugin/compiler-plugin-backend/src/main/v_2_2/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt +++ b/compiler-plugin/compiler-plugin-backend/src/main/v_2_2/kotlinx/rpc/codegen/VersionSpecificApiImpl.kt @@ -4,6 +4,7 @@ package kotlinx.rpc.codegen +import kotlinx.rpc.codegen.extension.IrMemberAccessExpressionData import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext import org.jetbrains.kotlin.backend.common.ir.createExtensionReceiver import org.jetbrains.kotlin.cli.common.messages.MessageCollector @@ -13,6 +14,7 @@ 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.IrMemberAccessExpression import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl @@ -133,4 +135,43 @@ object VersionSpecificApiImpl : VersionSpecificApi { source = source, ) } + + override fun IrFunction.valueParametersVS(): List { + return parameters.filter { it.kind == IrParameterKind.Regular } + } + + override val IrFunction.extensionReceiverParameterVS: IrValueParameter? + get() = parameters.firstOrNull { it.kind == IrParameterKind.ExtensionReceiver } + + override var IrFunction.dispatchReceiverParameterVS: IrValueParameter? + get() = dispatchReceiverParameter + set(value) { + if (value != null) { + parameters += value + } + } + + override fun IrMemberAccessExpressionData.buildFor(access: IrMemberAccessExpression<*>) { + var offset = if (dispatchReceiver != null) { + access.arguments[0] = dispatchReceiver + 1 + } else { + 0 + } + + offset += if (extensionReceiver != null) { + access.arguments[offset] = extensionReceiver + 1 + } else { + 0 + } + + valueArguments.forEachIndexed { index, irExpression -> + access.arguments[offset + index] = irExpression + } + + typeArguments.forEachIndexed { index, irType -> + access.typeArguments[index] = irType + } + } } diff --git a/compiler-plugin/compiler-plugin-k2/build.gradle.kts b/compiler-plugin/compiler-plugin-k2/build.gradle.kts index e2997f05b..4c9be9d38 100644 --- a/compiler-plugin/compiler-plugin-k2/build.gradle.kts +++ b/compiler-plugin/compiler-plugin-k2/build.gradle.kts @@ -4,9 +4,10 @@ import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar import org.jetbrains.kotlin.gradle.dsl.ExplicitApiMode -import util.enableContextReceivers +import util.enableContextParameters import util.otherwise import util.whenForIde +import util.whenKotlinIsAtLeast plugins { alias(libs.plugins.conventions.jvm) @@ -68,7 +69,9 @@ tasks.jar { kotlin { explicitApi = ExplicitApiMode.Disabled - enableContextReceivers() + rootProject.whenKotlinIsAtLeast(2, 2, 0) { + enableContextParameters() + } } dependencies { diff --git a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/FirRpcServiceGenerator.kt b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/FirRpcServiceGenerator.kt index c84c46673..9d5300101 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/FirRpcServiceGenerator.kt +++ b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/FirRpcServiceGenerator.kt @@ -11,19 +11,16 @@ import kotlinx.rpc.codegen.common.rpcMethodName import kotlinx.rpc.codegen.serialization.addAnnotation import kotlinx.rpc.codegen.serialization.generateCompanionDeclaration import kotlinx.rpc.codegen.serialization.generateSerializerImplClass -import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity import org.jetbrains.kotlin.cli.common.messages.MessageCollector 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.FirFunction import org.jetbrains.kotlin.fir.declarations.utils.isInterface import org.jetbrains.kotlin.fir.declarations.utils.visibility import org.jetbrains.kotlin.fir.extensions.* import org.jetbrains.kotlin.fir.moduleData import org.jetbrains.kotlin.fir.plugin.* -import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef @@ -261,10 +258,7 @@ class FirRpcServiceGenerator( * Scrapes the functions from the [owner] to generate method classes. */ private fun generateRpcServiceStubClass(owner: FirClassSymbol<*>): FirRegularClassSymbol? { - @OptIn(SymbolInternals::class) - val functions = owner.fir.declarations - .filterIsInstance() - .map { it.symbol } + val functions = vsApi { owner.declaredFunctionsVS(session) } return createNestedClass(owner, RpcNames.SERVICE_STUB_NAME, RpcGeneratedStubKey(owner.name, functions)) { visibility = Visibilities.Public diff --git a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/FirVersionSpecificApi.kt b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/FirVersionSpecificApi.kt index 8f834bce1..508e17438 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/FirVersionSpecificApi.kt +++ b/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> + + fun FirRegularClassSymbol.constructorsVS(session: FirSession): List + + fun FirRegularClass.declarationsVS(session: FirSession): List> + + val FirResolvedTypeRef.coneTypeVS: ConeKotlinType } inline fun vsApi(body: FirVersionSpecificApi.() -> T): T { diff --git a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirCheckedAnnotationCheckers.kt b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirCheckedAnnotationCheckers.kt index 8760fe81a..1b5f62cef 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirCheckedAnnotationCheckers.kt +++ b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirCheckedAnnotationCheckers.kt @@ -16,12 +16,7 @@ import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.FirTypeRefSource -import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirFunctionChecker -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirTypeParameterChecker -import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker import org.jetbrains.kotlin.fir.analysis.checkers.extractArgumentsTypeRefAndSource import org.jetbrains.kotlin.fir.caches.getValue import org.jetbrains.kotlin.fir.declarations.FirClass @@ -33,15 +28,15 @@ import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.resolve.defaultType 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.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.name.ClassId -class FirCheckedAnnotationFunctionCallChecker( - private val ctx: FirCheckersContext, -) : FirFunctionCallChecker(MppCheckerKind.Common) { - override fun check( +object FirCheckedAnnotationFunctionCallChecker { + fun check( + ctx: FirCheckersContext, expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter, @@ -61,10 +56,9 @@ class FirCheckedAnnotationFunctionCallChecker( } } -class FirCheckedAnnotationTypeParameterChecker( - private val ctx: FirCheckersContext, -) : FirTypeParameterChecker(MppCheckerKind.Common) { - override fun check( +object FirCheckedAnnotationTypeParameterChecker { + fun check( + ctx: FirCheckersContext, declaration: FirTypeParameter, context: CheckerContext, reporter: DiagnosticReporter, @@ -87,10 +81,9 @@ class FirCheckedAnnotationTypeParameterChecker( } } -class FirCheckedAnnotationFirClassChecker( - private val ctx: FirCheckersContext, -) : FirClassChecker(MppCheckerKind.Common) { - override fun check( +object FirCheckedAnnotationFirClassChecker { + fun check( + ctx: FirCheckersContext, declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter, @@ -113,10 +106,9 @@ class FirCheckedAnnotationFirClassChecker( } } -class FirCheckedAnnotationFirFunctionChecker( - private val ctx: FirCheckersContext, -) : FirFunctionChecker(MppCheckerKind.Common) { - override fun check( +object FirCheckedAnnotationFirFunctionChecker { + fun check( + ctx: FirCheckersContext, declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter, @@ -240,7 +232,7 @@ object FirCheckedAnnotationHelper { ?.let { FirTypeRefSource(it.typeRef, it.source) } ?: (origin as? FirTypeRef)?.let { FirTypeRefSource(it, it.source) } - checkTypeArguments, ConeTypeProjection>( + checkTypeArguments( context = context, reporter = reporter, ctx = ctx, @@ -283,6 +275,7 @@ object FirCheckedAnnotationHelper { } } + @OptIn(SymbolInternals::class) fun checkedAnnotations( session: FirSession, symbol: FirBasedSymbol<*>, @@ -327,6 +320,7 @@ object FirCheckedAnnotationHelper { } } + @OptIn(SymbolInternals::class) private fun hasCheckedAnnotation( session: FirSession, symbol: FirBasedSymbol<*>, diff --git a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcAnnotationChecker.kt b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcAnnotationChecker.kt index 0e2a7ec35..edf1ca500 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcAnnotationChecker.kt +++ b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcAnnotationChecker.kt @@ -15,16 +15,15 @@ import kotlinx.rpc.codegen.rpcAnnotationSource import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn -import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.utils.isInterface import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider import org.jetbrains.kotlin.fir.types.resolvedType -class FirRpcAnnotationChecker(private val ctx: FirCheckersContext) : FirRegularClassChecker(MppCheckerKind.Common) { - override fun check( +object FirRpcAnnotationChecker { + fun check( + ctx: FirCheckersContext, declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter, diff --git a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcCheckers.kt b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcCheckers.kt index 1b3fa83fe..c29af0220 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcCheckers.kt +++ b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcCheckers.kt @@ -15,27 +15,27 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChec class FirRpcDeclarationCheckers(ctx: FirCheckersContext) : DeclarationCheckers() { override val regularClassCheckers: Set = setOfNotNull( - FirRpcAnnotationChecker(ctx), - if (ctx.serializationIsPresent) FirRpcStrictModeClassChecker(ctx) else null, - FirRpcServiceDeclarationChecker(ctx), + FirRpcAnnotationCheckerVS(ctx), + if (ctx.serializationIsPresent) FirRpcStrictModeClassCheckerVS(ctx) else null, + FirRpcServiceDeclarationCheckerVS(ctx), ) override val classCheckers: Set = setOf( - FirCheckedAnnotationFirClassChecker(ctx), + FirCheckedAnnotationFirClassCheckerVS(ctx), ) override val functionCheckers: Set = setOf( - FirCheckedAnnotationFirFunctionChecker(ctx) + FirCheckedAnnotationFirFunctionCheckerVS(ctx) ) override val typeParameterCheckers: Set = setOf( - FirCheckedAnnotationTypeParameterChecker(ctx) + FirCheckedAnnotationTypeParameterCheckerVS(ctx) ) } class FirRpcExpressionCheckers(ctx: FirCheckersContext) : ExpressionCheckers() { override val functionCallCheckers: Set = setOf( - FirCheckedAnnotationFunctionCallChecker(ctx), - FirRpcStrictModeExpressionChecker(ctx), + FirCheckedAnnotationFunctionCallCheckerVS(ctx), + FirRpcStrictModeExpressionCheckerVS(ctx), ) } diff --git a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcServiceDeclarationChecker.kt b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcServiceDeclarationChecker.kt index 098021b19..52417ff7d 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcServiceDeclarationChecker.kt +++ b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcServiceDeclarationChecker.kt @@ -11,21 +11,16 @@ import kotlinx.rpc.codegen.common.RpcClassId import kotlinx.rpc.codegen.vsApi import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn -import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker -import org.jetbrains.kotlin.fir.declarations.FirClass -import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.utils.isSuspend import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol -class FirRpcServiceDeclarationChecker( - @Suppress("unused") - private val ctx: FirCheckersContext, -) : FirClassChecker(MppCheckerKind.Common) { - override fun check( - declaration: FirClass, +object FirRpcServiceDeclarationChecker { + fun check( + @Suppress("unused") ctx: FirCheckersContext, + declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter, ) { @@ -41,8 +36,12 @@ class FirRpcServiceDeclarationChecker( ) } - declaration.declarations.filterIsInstance().onEach { function -> - if (function.typeParameters.isNotEmpty()) { + vsApi { + declaration + .declarationsVS(context.session) + .filterIsInstance() + }.onEach { function -> + if (function.typeParameterSymbols.isNotEmpty()) { reporter.reportOn( source = function.source, factory = FirRpcDiagnostics.TYPE_PARAMETERS_IN_RPC_FUNCTION, @@ -50,7 +49,7 @@ class FirRpcServiceDeclarationChecker( ) } - val returnType = vsApi { function.returnTypeRef.coneType.toClassSymbolVS(context.session) } + val returnType = vsApi { function.resolvedReturnTypeRef.coneTypeVS.toClassSymbolVS(context.session) } ?: return@onEach if (returnType.classId != RpcClassId.flow && !function.isSuspend) { diff --git a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcStrictModeClassChecker.kt b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcStrictModeClassChecker.kt index 4c76ee506..5f6eaf1c6 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcStrictModeClassChecker.kt +++ b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/checkers/FirRpcStrictModeClassChecker.kt @@ -14,15 +14,10 @@ import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactory0 import org.jetbrains.kotlin.diagnostics.reportOn -import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker -import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker import org.jetbrains.kotlin.fir.analysis.checkers.extractArgumentsTypeRefAndSource import org.jetbrains.kotlin.fir.analysis.checkers.toClassLikeSymbol -import org.jetbrains.kotlin.fir.declarations.FirClass -import org.jetbrains.kotlin.fir.declarations.FirProperty -import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.utils.isSuspend import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider @@ -30,16 +25,15 @@ import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.scopes.impl.toConeType import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.types.FirTypeRef -import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.utils.memoryOptimizedMap import org.jetbrains.kotlin.utils.memoryOptimizedPlus import org.jetbrains.kotlinx.serialization.compiler.fir.services.FirSerializablePropertiesProvider import org.jetbrains.kotlinx.serialization.compiler.fir.services.serializablePropertiesProvider -class FirRpcStrictModeExpressionChecker( - private val ctx: FirCheckersContext, -) : FirFunctionCallChecker(MppCheckerKind.Common) { +object FirRpcStrictModeExpressionChecker { private val streamScopeFunctions = setOf( RpcCallableId.StreamScope, RpcCallableId.streamScoped, @@ -47,7 +41,8 @@ class FirRpcStrictModeExpressionChecker( RpcCallableId.invokeOnStreamScopeCompletion, ) - override fun check( + fun check( + ctx: FirCheckersContext, expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter, @@ -62,9 +57,10 @@ class FirRpcStrictModeExpressionChecker( } } -class FirRpcStrictModeClassChecker(private val ctx: FirCheckersContext) : FirClassChecker(MppCheckerKind.Common) { - override fun check( - declaration: FirClass, +object FirRpcStrictModeClassChecker { + fun check( + ctx: FirCheckersContext, + declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter, ) { @@ -73,16 +69,16 @@ class FirRpcStrictModeClassChecker(private val ctx: FirCheckersContext) : FirCla } val serializablePropertiesProvider = context.session.serializablePropertiesProvider - declaration.declarations.forEach { declaration -> + vsApi { declaration.declarationsVS(context.session) }.forEach { declaration -> when (declaration) { - is FirProperty -> { + is FirPropertySymbol -> { ctx.strictModeDiagnostics.FIELD_IN_RPC_SERVICE?.let { reporter.reportOn(declaration.source, it, context) } } - is FirSimpleFunction -> { - checkFunction(declaration, context, reporter, serializablePropertiesProvider) + is FirNamedFunctionSymbol -> { + checkFunction(ctx, declaration, context, reporter, serializablePropertiesProvider) } else -> {} @@ -91,7 +87,8 @@ class FirRpcStrictModeClassChecker(private val ctx: FirCheckersContext) : FirCla } private fun checkFunction( - function: FirSimpleFunction, + ctx: FirCheckersContext, + function: FirNamedFunctionSymbol, context: CheckerContext, reporter: DiagnosticReporter, serializablePropertiesProvider: FirSerializablePropertiesProvider, @@ -101,14 +98,14 @@ class FirRpcStrictModeClassChecker(private val ctx: FirCheckersContext) : FirCla } val returnClassSymbol = vsApi { - function.returnTypeRef.coneType.toClassSymbolVS(context.session) + function.resolvedReturnTypeRef.coneTypeVS.toClassSymbolVS(context.session) } - val types = function.valueParameters.memoryOptimizedMap { parameter -> + val types = function.valueParameterSymbols.memoryOptimizedMap { parameter -> parameter.source to vsApi { - parameter.returnTypeRef + parameter.resolvedReturnTypeRef } - } memoryOptimizedPlus (function.returnTypeRef.source to function.returnTypeRef) + } memoryOptimizedPlus (function.resolvedReturnTypeRef.source to function.resolvedReturnTypeRef) types.forEach { (source, symbol) -> checkSerializableTypes>( @@ -170,7 +167,7 @@ class FirRpcStrictModeClassChecker(private val ctx: FirCheckersContext) : FirCla } val flowProps: List = if (symbol.classId == RpcClassId.flow) { - listOf(extracted.values.toList()[0]!!) + listOf(extracted.values.toList()[0]!!) } else { emptyList() } diff --git a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/serialization/annotation.kt b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/serialization/annotation.kt index be85e4d5d..f0830b5b5 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/serialization/annotation.kt +++ b/compiler-plugin/compiler-plugin-k2/src/main/core/kotlinx/rpc/codegen/serialization/annotation.kt @@ -12,11 +12,9 @@ import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationCall import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider -import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull fun FirAnnotationContainer.addAnnotation(annotationId: ClassId, session: FirSession) { val annotation = session @@ -24,9 +22,11 @@ fun FirAnnotationContainer.addAnnotation(annotationId: ClassId, session: FirSess .getClassLikeSymbolByClassId(annotationId) as? FirRegularClassSymbol ?: return - val annotationConstructor = annotation - .declarationSymbols - .firstIsInstanceOrNull() ?: return + val annotationConstructor = vsApi { + annotation + .constructorsVS(session) + .firstOrNull() ?: return + } val annotationCall = buildAnnotationCall { argumentList = buildResolvedArgumentList(null, linkedMapOf()) diff --git a/compiler-plugin/compiler-plugin-k2/src/main/latest/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt b/compiler-plugin/compiler-plugin-k2/src/main/latest/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt index 4187d7ff2..2a7771ad3 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/latest/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt +++ b/compiler-plugin/compiler-plugin-k2/src/main/latest/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt @@ -6,15 +6,21 @@ 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 import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.builder.FirResolvedTypeRefBuilder -@Suppress("unused") object FirVersionSpecificApiImpl : FirVersionSpecificApi { override fun ConeKotlinType.toFirResolvedTypeRefVS( source: KtSourceElement?, @@ -32,4 +38,21 @@ object FirVersionSpecificApiImpl : FirVersionSpecificApi { set(value) { coneType = value } + + override fun FirClassSymbol<*>.declaredFunctionsVS(session: FirSession): List> { + @OptIn(SymbolInternals::class) + return fir.declarations + .filterIsInstance() + .map { it.symbol } + } + + override fun FirRegularClassSymbol.constructorsVS(session: FirSession): List { + return declarationSymbols.filterIsInstance() + } + + override fun FirRegularClass.declarationsVS(session: FirSession): List> { + return declarations.map { it.symbol } + } + + override val FirResolvedTypeRef.coneTypeVS: ConeKotlinType get() = coneType } diff --git a/compiler-plugin/compiler-plugin-k2/src/main/latest/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt b/compiler-plugin/compiler-plugin-k2/src/main/latest/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt new file mode 100644 index 000000000..ca76f64c2 --- /dev/null +++ b/compiler-plugin/compiler-plugin-k2/src/main/latest/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt @@ -0,0 +1,80 @@ +/* + * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. + */ + +package kotlinx.rpc.codegen.checkers + +import kotlinx.rpc.codegen.FirCheckersContext +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirFunctionChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirTypeParameterChecker +import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker +import org.jetbrains.kotlin.fir.declarations.FirClass +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall + +class FirCheckedAnnotationFunctionCallCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionCallChecker(MppCheckerKind.Common) { + override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { + FirCheckedAnnotationFunctionCallChecker.check(ctx, expression, context, reporter) + } +} + +class FirCheckedAnnotationTypeParameterCheckerVS( + private val ctx: FirCheckersContext, +) : FirTypeParameterChecker(MppCheckerKind.Common) { + 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(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirCheckedAnnotationFirClassChecker.check(ctx, declaration, context, reporter) + } +} + +class FirCheckedAnnotationFirFunctionCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionChecker(MppCheckerKind.Common) { + 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(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcAnnotationChecker.check(ctx, declaration, context, reporter) + } +} + +class FirRpcServiceDeclarationCheckerVS( + private val ctx: FirCheckersContext, +) : FirRegularClassChecker(MppCheckerKind.Common) { + override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcServiceDeclarationChecker.check(ctx, declaration, context, reporter) + } +} + +class FirRpcStrictModeExpressionCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionCallChecker(MppCheckerKind.Common) { + override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcStrictModeExpressionChecker.check(ctx, expression, context, reporter) + } +} + +class FirRpcStrictModeClassCheckerVS(private val ctx: FirCheckersContext) : FirRegularClassChecker(MppCheckerKind.Common) { + override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcStrictModeClassChecker.check(ctx, declaration, context, reporter) + } +} diff --git a/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_10/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt b/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_10/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt index c45c42192..72afcf7ff 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_10/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt +++ b/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_10/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt @@ -14,8 +14,14 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.toFirResolvedTypeRef import org.jetbrains.kotlin.fir.types.builder.FirResolvedTypeRefBuilder import org.jetbrains.kotlin.fir.types.toClassSymbol +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -@Suppress("unused") object FirVersionSpecificApiImpl : FirVersionSpecificApi { override fun ConeKotlinType.toFirResolvedTypeRefVS( source: KtSourceElement?, @@ -33,4 +39,21 @@ object FirVersionSpecificApiImpl : FirVersionSpecificApi { set(value) { type = value } + + override fun FirClassSymbol<*>.declaredFunctionsVS(session: FirSession): List> { + @OptIn(SymbolInternals::class) + return fir.declarations + .filterIsInstance() + .map { it.symbol } + } + + override fun FirRegularClassSymbol.constructorsVS(session: FirSession): List { + return declarationSymbols.filterIsInstance() + } + + override fun FirRegularClass.declarationsVS(session: FirSession): List> { + return declarations.map { it.symbol } + } + + override val FirResolvedTypeRef.coneTypeVS: ConeKotlinType get() = type } diff --git a/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_10/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt b/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_10/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt new file mode 100644 index 000000000..ca76f64c2 --- /dev/null +++ b/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_10/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt @@ -0,0 +1,80 @@ +/* + * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. + */ + +package kotlinx.rpc.codegen.checkers + +import kotlinx.rpc.codegen.FirCheckersContext +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirFunctionChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirTypeParameterChecker +import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker +import org.jetbrains.kotlin.fir.declarations.FirClass +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall + +class FirCheckedAnnotationFunctionCallCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionCallChecker(MppCheckerKind.Common) { + override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { + FirCheckedAnnotationFunctionCallChecker.check(ctx, expression, context, reporter) + } +} + +class FirCheckedAnnotationTypeParameterCheckerVS( + private val ctx: FirCheckersContext, +) : FirTypeParameterChecker(MppCheckerKind.Common) { + 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(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirCheckedAnnotationFirClassChecker.check(ctx, declaration, context, reporter) + } +} + +class FirCheckedAnnotationFirFunctionCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionChecker(MppCheckerKind.Common) { + 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(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcAnnotationChecker.check(ctx, declaration, context, reporter) + } +} + +class FirRpcServiceDeclarationCheckerVS( + private val ctx: FirCheckersContext, +) : FirRegularClassChecker(MppCheckerKind.Common) { + override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcServiceDeclarationChecker.check(ctx, declaration, context, reporter) + } +} + +class FirRpcStrictModeExpressionCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionCallChecker(MppCheckerKind.Common) { + override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcStrictModeExpressionChecker.check(ctx, expression, context, reporter) + } +} + +class FirRpcStrictModeClassCheckerVS(private val ctx: FirCheckersContext) : FirRegularClassChecker(MppCheckerKind.Common) { + override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcStrictModeClassChecker.check(ctx, declaration, context, reporter) + } +} diff --git a/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_21/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt b/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_21/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt index b92a1be57..06b4f6c63 100644 --- a/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_21/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt +++ b/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_21/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt @@ -13,8 +13,14 @@ import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.builder.FirResolvedTypeRefBuilder import org.jetbrains.kotlin.fir.types.toClassSymbol +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -@Suppress("unused") object FirVersionSpecificApiImpl : FirVersionSpecificApi { override fun ConeKotlinType.toFirResolvedTypeRefVS( source: KtSourceElement?, @@ -32,4 +38,21 @@ object FirVersionSpecificApiImpl : FirVersionSpecificApi { set(value) { type = value } + + override fun FirClassSymbol<*>.declaredFunctionsVS(session: FirSession): List> { + @OptIn(SymbolInternals::class) + return fir.declarations + .filterIsInstance() + .map { it.symbol } + } + + override fun FirRegularClassSymbol.constructorsVS(session: FirSession): List { + return declarationSymbols.filterIsInstance() + } + + override fun FirRegularClass.declarationsVS(session: FirSession): List> { + return declarations.map { it.symbol } + } + + override val FirResolvedTypeRef.coneTypeVS: ConeKotlinType get() = type } diff --git a/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_21/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt b/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_21/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt new file mode 100644 index 000000000..ca76f64c2 --- /dev/null +++ b/compiler-plugin/compiler-plugin-k2/src/main/pre_2_0_21/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt @@ -0,0 +1,80 @@ +/* + * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. + */ + +package kotlinx.rpc.codegen.checkers + +import kotlinx.rpc.codegen.FirCheckersContext +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirFunctionChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirTypeParameterChecker +import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker +import org.jetbrains.kotlin.fir.declarations.FirClass +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall + +class FirCheckedAnnotationFunctionCallCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionCallChecker(MppCheckerKind.Common) { + override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { + FirCheckedAnnotationFunctionCallChecker.check(ctx, expression, context, reporter) + } +} + +class FirCheckedAnnotationTypeParameterCheckerVS( + private val ctx: FirCheckersContext, +) : FirTypeParameterChecker(MppCheckerKind.Common) { + 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(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirCheckedAnnotationFirClassChecker.check(ctx, declaration, context, reporter) + } +} + +class FirCheckedAnnotationFirFunctionCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionChecker(MppCheckerKind.Common) { + 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(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcAnnotationChecker.check(ctx, declaration, context, reporter) + } +} + +class FirRpcServiceDeclarationCheckerVS( + private val ctx: FirCheckersContext, +) : FirRegularClassChecker(MppCheckerKind.Common) { + override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcServiceDeclarationChecker.check(ctx, declaration, context, reporter) + } +} + +class FirRpcStrictModeExpressionCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionCallChecker(MppCheckerKind.Common) { + override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcStrictModeExpressionChecker.check(ctx, expression, context, reporter) + } +} + +class FirRpcStrictModeClassCheckerVS(private val ctx: FirCheckersContext) : FirRegularClassChecker(MppCheckerKind.Common) { + override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { + FirRpcStrictModeClassChecker.check(ctx, declaration, context, reporter) + } +} diff --git a/compiler-plugin/compiler-plugin-k2/src/main/v_2_2/kotlinx/rpc/codegen/FirRpcSupertypeGenerator.kt b/compiler-plugin/compiler-plugin-k2/src/main/v_2_2/kotlinx/rpc/codegen/FirRpcSupertypeGenerator.kt new file mode 100644 index 000000000..90269d1d8 --- /dev/null +++ b/compiler-plugin/compiler-plugin-k2/src/main/v_2_2/kotlinx/rpc/codegen/FirRpcSupertypeGenerator.kt @@ -0,0 +1,27 @@ +/* + * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. + */ + +package kotlinx.rpc.codegen + +import org.jetbrains.kotlin.cli.common.messages.MessageCollector +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef +import org.jetbrains.kotlin.fir.types.constructClassLikeType + +class FirRpcSupertypeGenerator( + session: FirSession, + logger: MessageCollector, +) : FirRpcSupertypeGeneratorAbstract(session, logger) { + override fun computeAdditionalSupertypes( + classLikeDeclaration: FirClassLikeDeclaration, + resolvedSupertypes: List, + typeResolver: TypeResolveService, + ): List { + return computeAdditionalSupertypesAbstract(resolvedSupertypes).map { + it.constructClassLikeType(emptyArray(), isMarkedNullable = false) + } + } +} diff --git a/compiler-plugin/compiler-plugin-k2/src/main/v_2_2/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt b/compiler-plugin/compiler-plugin-k2/src/main/v_2_2/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt new file mode 100644 index 000000000..f46edc617 --- /dev/null +++ b/compiler-plugin/compiler-plugin-k2/src/main/v_2_2/kotlinx/rpc/codegen/FirVersionSpecificApiImpl.kt @@ -0,0 +1,61 @@ +/* + * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. + */ + +package kotlinx.rpc.codegen + +import org.jetbrains.kotlin.KtSourceElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.declaredFunctions +import org.jetbrains.kotlin.fir.declarations.constructors +import org.jetbrains.kotlin.fir.resolve.toClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.toFirResolvedTypeRef +import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef +import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.types.builder.FirResolvedTypeRefBuilder +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.processAllDeclarations +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol + +object FirVersionSpecificApiImpl : FirVersionSpecificApi { + override fun ConeKotlinType.toFirResolvedTypeRefVS( + source: KtSourceElement?, + delegatedTypeRef: FirTypeRef?, + ): FirResolvedTypeRef { + return toFirResolvedTypeRef(source, delegatedTypeRef) + } + + override fun ConeKotlinType.toClassSymbolVS(session: FirSession): FirClassSymbol<*>? { + return toClassSymbol(session) + } + + override var FirResolvedTypeRefBuilder.coneTypeVS: ConeKotlinType + get() = coneType + set(value) { + coneType = value + } + + override fun FirClassSymbol<*>.declaredFunctionsVS(session: FirSession): List> { + return declaredFunctions(session) + } + + override fun FirRegularClassSymbol.constructorsVS(session: FirSession): List { + return constructors(session) + } + + override fun FirRegularClass.declarationsVS(session: FirSession): List> { + val declarations = mutableListOf>() + processAllDeclarations(session) { symbol -> + declarations.add(symbol) + } + return declarations + } + + override val FirResolvedTypeRef.coneTypeVS: ConeKotlinType get() = coneType +} diff --git a/compiler-plugin/compiler-plugin-k2/src/main/v_2_2/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt b/compiler-plugin/compiler-plugin-k2/src/main/v_2_2/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt new file mode 100644 index 000000000..684070a55 --- /dev/null +++ b/compiler-plugin/compiler-plugin-k2/src/main/v_2_2/kotlinx/rpc/codegen/checkers/FirRpcCheckersVS.kt @@ -0,0 +1,88 @@ +/* + * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. + */ + +package kotlinx.rpc.codegen.checkers + +import kotlinx.rpc.codegen.FirCheckersContext +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirFunctionChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirTypeParameterChecker +import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker +import org.jetbrains.kotlin.fir.declarations.FirClass +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall + +class FirCheckedAnnotationFunctionCallCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionCallChecker(MppCheckerKind.Common) { + context(context: CheckerContext, reporter: DiagnosticReporter) + override fun check(expression: FirFunctionCall) { + FirCheckedAnnotationFunctionCallChecker.check(ctx, expression, context, reporter) + } +} + +class FirCheckedAnnotationTypeParameterCheckerVS( + private val ctx: FirCheckersContext, +) : FirTypeParameterChecker(MppCheckerKind.Common) { + context(context: CheckerContext, reporter: DiagnosticReporter) + override fun check(declaration: FirTypeParameter) { + FirCheckedAnnotationTypeParameterChecker.check(ctx, declaration, context, reporter) + } +} + +class FirCheckedAnnotationFirClassCheckerVS( + private val ctx: FirCheckersContext, +) : FirClassChecker(MppCheckerKind.Common) { + context(context: CheckerContext, reporter: DiagnosticReporter) + override fun check(declaration: FirClass) { + FirCheckedAnnotationFirClassChecker.check(ctx, declaration, context, reporter) + } +} + +class FirCheckedAnnotationFirFunctionCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionChecker(MppCheckerKind.Common) { + context(context: CheckerContext, reporter: DiagnosticReporter) + override fun check(declaration: FirFunction) { + FirCheckedAnnotationFirFunctionChecker.check(ctx, declaration, context, reporter) + } +} + +class FirRpcAnnotationCheckerVS(private val ctx: FirCheckersContext) : FirRegularClassChecker(MppCheckerKind.Common) { + context(context: CheckerContext, reporter: DiagnosticReporter) + override fun check(declaration: FirRegularClass) { + FirRpcAnnotationChecker.check(ctx, declaration, context, reporter) + } +} + +class FirRpcServiceDeclarationCheckerVS( + private val ctx: FirCheckersContext, +) : FirRegularClassChecker(MppCheckerKind.Common) { + context(context: CheckerContext, reporter: DiagnosticReporter) + override fun check(declaration: FirRegularClass) { + FirRpcServiceDeclarationChecker.check(ctx, declaration, context, reporter) + } +} + +class FirRpcStrictModeExpressionCheckerVS( + private val ctx: FirCheckersContext, +) : FirFunctionCallChecker(MppCheckerKind.Common) { + context(context: CheckerContext, reporter: DiagnosticReporter) + override fun check(expression: FirFunctionCall) { + FirRpcStrictModeExpressionChecker.check(ctx, expression, context, reporter) + } +} + +class FirRpcStrictModeClassCheckerVS(private val ctx: FirCheckersContext) : FirRegularClassChecker(MppCheckerKind.Common) { + context(context: CheckerContext, reporter: DiagnosticReporter) + override fun check(declaration: FirRegularClass) { + FirRpcStrictModeClassChecker.check(ctx, declaration, context, reporter) + } +} diff --git a/gradle-conventions-settings/build.gradle.kts b/gradle-conventions-settings/build.gradle.kts index 8f01452ea..57d367312 100644 --- a/gradle-conventions-settings/build.gradle.kts +++ b/gradle-conventions-settings/build.gradle.kts @@ -6,14 +6,6 @@ plugins { alias(libs.plugins.gradle.kotlin.dsl) } -configurations.configureEach { - resolutionStrategy { - force(libs.kotlin.stdlib) - force(libs.kotlin.stdlib.jdk7) - force(libs.kotlin.stdlib.jdk8) - } -} - dependencies { // https://stackoverflow.com/questions/76713758/use-version-catalog-inside-precompiled-gradle-plugin api(files(libs.javaClass.superclass.protectionDomain.codeSource.location)) diff --git a/gradle-conventions-settings/develocity/build.gradle.kts b/gradle-conventions-settings/develocity/build.gradle.kts index a5ad90b45..931ab66b6 100644 --- a/gradle-conventions-settings/develocity/build.gradle.kts +++ b/gradle-conventions-settings/develocity/build.gradle.kts @@ -6,14 +6,6 @@ plugins { alias(libs.plugins.gradle.kotlin.dsl) } -configurations.configureEach { - resolutionStrategy { - force(libs.kotlin.stdlib) - force(libs.kotlin.stdlib.jdk7) - force(libs.kotlin.stdlib.jdk8) - } -} - dependencies { implementation("com.gradle:develocity-gradle-plugin:3.17") implementation("com.gradle:common-custom-user-data-gradle-plugin:2.2.1") diff --git a/gradle-conventions-settings/src/main/kotlin/util/conventionsDefaults.kt b/gradle-conventions-settings/src/main/kotlin/util/conventionsDefaults.kt deleted file mode 100644 index 20fd54a40..000000000 --- a/gradle-conventions-settings/src/main/kotlin/util/conventionsDefaults.kt +++ /dev/null @@ -1,17 +0,0 @@ -/* - * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. - */ - -package util - -import org.gradle.api.Project - -fun Project.defaultConventionConfiguration() { - configurations.configureEach { - resolutionStrategy { - force(libs.kotlin.stdlib) - force(libs.kotlin.stdlib.jdk7) - force(libs.kotlin.stdlib.jdk8) - } - } -} diff --git a/gradle-conventions/build.gradle.kts b/gradle-conventions/build.gradle.kts index 5c074a09f..3687d55b4 100644 --- a/gradle-conventions/build.gradle.kts +++ b/gradle-conventions/build.gradle.kts @@ -2,7 +2,6 @@ * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. */ -import util.defaultConventionConfiguration import util.otherwise import util.whenKotlinLatest @@ -10,8 +9,6 @@ plugins { alias(libs.plugins.gradle.kotlin.dsl) } -defaultConventionConfiguration() - dependencies { implementation(project(":common")) implementation(":gradle-conventions-settings") diff --git a/gradle-conventions/common/build.gradle.kts b/gradle-conventions/common/build.gradle.kts index d14cefe08..846533eca 100644 --- a/gradle-conventions/common/build.gradle.kts +++ b/gradle-conventions/common/build.gradle.kts @@ -2,14 +2,10 @@ * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. */ -import util.defaultConventionConfiguration - plugins { alias(libs.plugins.gradle.kotlin.dsl) } -defaultConventionConfiguration() - val isLatestKotlinVersion: Boolean by extra dependencies { diff --git a/gradle-conventions/latest-only/build.gradle.kts b/gradle-conventions/latest-only/build.gradle.kts index d92836c09..70c9995bc 100644 --- a/gradle-conventions/latest-only/build.gradle.kts +++ b/gradle-conventions/latest-only/build.gradle.kts @@ -2,14 +2,10 @@ * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. */ -import util.defaultConventionConfiguration - plugins { alias(libs.plugins.gradle.kotlin.dsl) } -defaultConventionConfiguration() - dependencies { implementation(project(":common")) diff --git a/gradle-conventions/src/main/kotlin/util/contextReceivers.kt b/gradle-conventions/src/main/kotlin/util/contextParameters.kt similarity index 74% rename from gradle-conventions/src/main/kotlin/util/contextReceivers.kt rename to gradle-conventions/src/main/kotlin/util/contextParameters.kt index b435321ce..5dcc323c5 100644 --- a/gradle-conventions/src/main/kotlin/util/contextReceivers.kt +++ b/gradle-conventions/src/main/kotlin/util/contextParameters.kt @@ -7,17 +7,17 @@ package util import org.gradle.api.Project import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi -fun Project.enableContextReceivers() { +fun Project.enableContextParameters() { withKotlinJvmExtension { compilerOptions { - freeCompilerArgs.add("-Xcontext-receivers") + freeCompilerArgs.add("-Xcontext-parameters") } } withKotlinKmpExtension { @OptIn(ExperimentalKotlinGradlePluginApi::class) compilerOptions { - freeCompilerArgs.add("-Xcontext-receivers") + freeCompilerArgs.add("-Xcontext-parameters") } } } diff --git a/krpc/krpc-ktor/krpc-ktor-client/src/commonMain/kotlin/kotlinx/rpc/krpc/ktor/client/Krpc.kt b/krpc/krpc-ktor/krpc-ktor-client/src/commonMain/kotlin/kotlinx/rpc/krpc/ktor/client/Krpc.kt index 204c8b3c2..aef216e9f 100644 --- a/krpc/krpc-ktor/krpc-ktor-client/src/commonMain/kotlin/kotlinx/rpc/krpc/ktor/client/Krpc.kt +++ b/krpc/krpc-ktor/krpc-ktor-client/src/commonMain/kotlin/kotlinx/rpc/krpc/ktor/client/Krpc.kt @@ -23,9 +23,9 @@ public val Krpc: ClientPlugin = createClientPlugin("Kr } @Deprecated("Use installKrpc instead", ReplaceWith("installKrpc"), level = DeprecationLevel.ERROR) -public fun HttpClientConfig<*>.installRPC( - configure: KrpcConfigBuilder.Client.() -> Unit = {} -) = installKrpc(configure) +public fun HttpClientConfig<*>.installRPC(configure: KrpcConfigBuilder.Client.() -> Unit = {}) { + installKrpc(configure) +} /** * Installs [WebSockets] and [Krpc] client plugins diff --git a/tests/compiler-plugin-tests/src/test-gen/kotlinx/rpc/codegen/test/runners/BoxTestGenerated.java b/tests/compiler-plugin-tests/src/test-gen/kotlinx/rpc/codegen/test/runners/BoxTestGenerated.java index 176ee2b49..9b0b0c3e5 100644 --- a/tests/compiler-plugin-tests/src/test-gen/kotlinx/rpc/codegen/test/runners/BoxTestGenerated.java +++ b/tests/compiler-plugin-tests/src/test-gen/kotlinx/rpc/codegen/test/runners/BoxTestGenerated.java @@ -1,9 +1,5 @@ -/* - * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. - */ - package kotlinx.rpc.codegen.test.runners; import com.intellij.testFramework.TestDataPath; diff --git a/tests/compiler-plugin-tests/src/test-gen/kotlinx/rpc/codegen/test/runners/DiagnosticTestGenerated.java b/tests/compiler-plugin-tests/src/test-gen/kotlinx/rpc/codegen/test/runners/DiagnosticTestGenerated.java index d32e8b6d5..a11e29765 100644 --- a/tests/compiler-plugin-tests/src/test-gen/kotlinx/rpc/codegen/test/runners/DiagnosticTestGenerated.java +++ b/tests/compiler-plugin-tests/src/test-gen/kotlinx/rpc/codegen/test/runners/DiagnosticTestGenerated.java @@ -1,9 +1,5 @@ -/* - * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license. - */ - package kotlinx.rpc.codegen.test.runners; import com.intellij.testFramework.TestDataPath; diff --git a/utils/src/commonMain/kotlin/kotlinx/rpc/internal/utils/deferredUtil.kt b/utils/src/commonMain/kotlin/kotlinx/rpc/internal/utils/deferredUtil.kt index 978c8c38d..8576de1f6 100644 --- a/utils/src/commonMain/kotlin/kotlinx/rpc/internal/utils/deferredUtil.kt +++ b/utils/src/commonMain/kotlin/kotlinx/rpc/internal/utils/deferredUtil.kt @@ -22,4 +22,4 @@ public operator fun RpcInternalConcurrentHashMap CompletableDeferred?.getOrNull() = if (this != null && isCompleted) this.getCompleted() else null +public fun CompletableDeferred?.getOrNull(): T? = if (this != null && isCompleted) this.getCompleted() else null diff --git a/versions-root/libs.versions.toml b/versions-root/libs.versions.toml index 8c1bafe1a..b2dc733f9 100644 --- a/versions-root/libs.versions.toml +++ b/versions-root/libs.versions.toml @@ -17,6 +17,7 @@ gradle-plugin-publish = "1.3.1" kotlin-wrappers = "2025.4.8" junit4 = "4.13.2" junit5 = "5.12.1" +#intellij = "241.19416.19" apply for 2.2.0 update intellij = "233.13135.128" gradle-doctor = "0.10.0" kotlinx-browser = "0.3"