diff --git a/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/BackInTimeIrGenerationExtension.kt b/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/BackInTimeIrGenerationExtension.kt index 42259770..b8f65095 100644 --- a/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/BackInTimeIrGenerationExtension.kt +++ b/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/BackInTimeIrGenerationExtension.kt @@ -6,18 +6,15 @@ import com.kitakkun.backintime.compiler.backend.transformer.capture.BackInTimeDe import com.kitakkun.backintime.compiler.backend.transformer.capture.BackInTimeDebuggableCapturePropertyChangesTransformer import com.kitakkun.backintime.compiler.backend.transformer.capture.BackInTimeDebuggableConstructorTransformer import com.kitakkun.backintime.compiler.backend.transformer.implement.BackInTimeDebuggableImplementTransformer -import com.kitakkun.backintime.compiler.common.BackInTimeCompilerConfiguration import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext import org.jetbrains.kotlin.ir.declarations.IrModuleFragment import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid -class BackInTimeIrGenerationExtension( - private val config: BackInTimeCompilerConfiguration, -) : IrGenerationExtension { +class BackInTimeIrGenerationExtension : IrGenerationExtension { override fun generate(moduleFragment: IrModuleFragment, pluginContext: IrPluginContext) { VersionSpecificAPI.INSTANCE = VersionSpecificAPIImpl - val context = BackInTimePluginContext(baseContext = pluginContext, config = config, moduleFragment = moduleFragment) + val context = BackInTimePluginContext(baseContext = pluginContext, moduleFragment = moduleFragment) with(context) { moduleFragment.transformChildrenVoid(BackInTimeDebuggableConstructorTransformer()) moduleFragment.transformChildrenVoid(BackInTimeDebuggableCapturePropertyChangesTransformer()) diff --git a/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/BackInTimePluginContext.kt b/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/BackInTimePluginContext.kt index 205a5c9b..2ac79aee 100644 --- a/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/BackInTimePluginContext.kt +++ b/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/BackInTimePluginContext.kt @@ -4,19 +4,20 @@ import com.kitakkun.backintime.compiler.backend.analyzer.UserDefinedValueContain import com.kitakkun.backintime.compiler.backend.api.VersionSpecificAPI import com.kitakkun.backintime.compiler.backend.valuecontainer.ValueContainerBuiltIns import com.kitakkun.backintime.compiler.backend.valuecontainer.resolved.ResolvedValueContainer -import com.kitakkun.backintime.compiler.common.BackInTimeCompilerConfiguration import com.kitakkun.backintime.compiler.common.BackInTimeConsts import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext import org.jetbrains.kotlin.ir.declarations.IrModuleFragment +import org.jetbrains.kotlin.ir.symbols.IrClassSymbol +import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol import org.jetbrains.kotlin.ir.util.constructors import org.jetbrains.kotlin.ir.util.isVararg +import org.jetbrains.kotlin.javac.resolve.classId import org.jetbrains.kotlin.name.CallableId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name class BackInTimePluginContext( baseContext: IrPluginContext, - config: BackInTimeCompilerConfiguration, moduleFragment: IrModuleFragment, ) : IrPluginContext by baseContext { val pluginContext: IrPluginContext = baseContext @@ -28,39 +29,63 @@ class BackInTimePluginContext( resolvedValueContainer } + UserDefinedValueContainerAnalyzer.analyzeAdditionalValueContainerClassInfo(moduleFragment) - private val internalCompilerApiPackageFqName = FqName("com.kitakkun.backintime.core.runtime.internal") - // event report functions - val reportInstanceRegistrationFunctionSymbol = referenceFunctions(CallableId(internalCompilerApiPackageFqName, Name.identifier("reportInstanceRegistration"))).first() - val reportMethodInvocationFunctionSymbol = referenceFunctions(CallableId(internalCompilerApiPackageFqName, Name.identifier("reportMethodInvocation"))).first() - val reportPropertyValueChangeFunctionSymbol = referenceFunctions(CallableId(internalCompilerApiPackageFqName, Name.identifier("reportPropertyValueChange"))).first() - val reportNewRelationshipFunctionSymbol = referenceFunctions(CallableId(internalCompilerApiPackageFqName, Name.identifier("reportNewRelationship"))).first() + val reportInstanceRegistrationFunctionSymbol by lazy { backintimeNamedFunction(name = "reportInstanceRegistration", subpackage = "core.runtime.internal") } + val reportMethodInvocationFunctionSymbol by lazy { backintimeNamedFunction(name = "reportMethodInvocation", subpackage = "core.runtime.internal") } + val reportPropertyValueChangeFunctionSymbol by lazy { backintimeNamedFunction(name = "reportPropertyValueChange", subpackage = "core.runtime.internal") } + val reportNewRelationshipFunctionSymbol by lazy { backintimeNamedFunction(name = "reportNewRelationship", subpackage = "core.runtime.internal") } // error generation functions - val throwTypeMismatchExceptionFunctionSymbol = referenceFunctions(CallableId(internalCompilerApiPackageFqName, Name.identifier("throwTypeMismatchException"))).first() - val throwNoSuchPropertyExceptionFunctionSymbol = referenceFunctions(CallableId(internalCompilerApiPackageFqName, Name.identifier("throwNoSuchPropertyException"))).first() + val throwTypeMismatchExceptionFunctionSymbol by lazy { backintimeNamedFunction(name = "throwTypeMismatchException", subpackage = "core.runtime.internal") } + val throwNoSuchPropertyExceptionFunctionSymbol by lazy { backintimeNamedFunction(name = "throwNoSuchPropertyException", subpackage = "core.runtime.internal") } // capture utils - val captureThenReturnValueFunctionSymbol = referenceFunctions(CallableId(internalCompilerApiPackageFqName, Name.identifier("captureThenReturnValue"))).first() + val captureThenReturnValueFunctionSymbol by lazy { backintimeNamedFunction(name = "captureThenReturnValue", subpackage = "core.runtime.internal") } /** * Used in [com.kitakkun.backintime.compiler.backend.transformer.BackInTimeDebuggableConstructorTransformer] */ - val propertyInfoClass = referenceClass(BackInTimeConsts.propertyInfoClassId)!! + val propertyInfoClass by lazy { backintimeIrClassSymbol(name = "PropertyInfo", subpackage = "core.websocket.event.model") } val propertyInfoClassConstructor = propertyInfoClass.constructors.first { it.owner.isPrimary } - val listOfFunction = referenceFunctions(BackInTimeConsts.listOfFunctionId).first { it.owner.valueParameters.size == 1 && it.owner.valueParameters.first().isVararg } + val listOfFunction by lazy { namedFunction("kotlin.collections", "listOf") { it.owner.valueParameters.size == 1 && it.owner.valueParameters.first().isVararg } } // kotlinx-serialization val backInTimeJsonGetter = referenceProperties(BackInTimeConsts.backInTimeJsonCallableId).single().owner.getter!! - val encodeToStringFunction = referenceFunctions(BackInTimeConsts.kotlinxSerializationEncodeToStringCallableId).firstOrNull { - VersionSpecificAPI.INSTANCE.isReifiable(it.owner) && it.owner.typeParameters.size == 1 && it.owner.valueParameters.size == 1 - } ?: error("${BackInTimeConsts.kotlinxSerializationEncodeToStringCallableId} is not found. Make sure you have kotlinx-serialization runtime dependency.") - val decodeFromStringFunction = referenceFunctions(BackInTimeConsts.kotlinxSerializationDecodeFromStringCallableId).firstOrNull { - VersionSpecificAPI.INSTANCE.isReifiable(it.owner) && it.owner.typeParameters.size == 1 && it.owner.valueParameters.size == 1 - } ?: error("${BackInTimeConsts.kotlinxSerializationDecodeFromStringCallableId} is not found. Make sure you have kotlinx-serialization runtime dependency.") + val encodeToStringFunction by lazy { + namedFunction("kotlinx.serialization", "encodeToString") { + VersionSpecificAPI.INSTANCE.isReifiable(it.owner) && it.owner.typeParameters.size == 1 && it.owner.valueParameters.size == 1 + } + } + val decodeFromStringFunction by lazy { + namedFunction("kotlinx.serialization", "decodeFromString") { + VersionSpecificAPI.INSTANCE.isReifiable(it.owner) && it.owner.typeParameters.size == 1 && it.owner.valueParameters.size == 1 + } + } // uuid - val uuidFunctionSymbol = referenceFunctions(CallableId(internalCompilerApiPackageFqName, Name.identifier("uuid"))).single() + val uuidFunctionSymbol by lazy { backintimeNamedFunction(name = "uuid", subpackage = "core.runtime.internal") } + + val mutableMapOfFunction by lazy { namedFunction("kotlin.collections", "mutableMapOf") } + + private fun namedFunction( + packageName: String, + name: String, + filter: (IrSimpleFunctionSymbol) -> Boolean = { true }, + ): IrSimpleFunctionSymbol { + val callableId = CallableId(FqName(packageName), Name.identifier(name)) + return pluginContext.referenceFunctions(callableId).first(filter) + } + + private fun backintimeNamedFunction(name: String, subpackage: String? = null): IrSimpleFunctionSymbol { + val suffix = subpackage?.let { ".$subpackage" } ?: "" + return namedFunction("com.kitakkun.backintime$suffix", name) + } + + private fun backintimeIrClassSymbol(name: String, subpackage: String? = null): IrClassSymbol { + val suffix = subpackage?.let { ".$subpackage" } ?: "" + return getIrClassSymbol("com.kitakkun.backintime$suffix", name) + } - val mutableMapOfFunction = referenceFunctions(CallableId(FqName("kotlin.collections"), Name.identifier("mutableMapOf"))).first { it.owner.isInline } + private fun getIrClassSymbol(packageName: String, name: String): IrClassSymbol = pluginContext.referenceClass(classId(packageName, name)) + ?: error("Unable to find symbol. Package: $packageName, Name: $name") } diff --git a/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/transformer/capture/BackInTimeDebuggableConstructorTransformer.kt b/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/transformer/capture/BackInTimeDebuggableConstructorTransformer.kt index 1fad7537..c91c89e4 100644 --- a/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/transformer/capture/BackInTimeDebuggableConstructorTransformer.kt +++ b/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/transformer/capture/BackInTimeDebuggableConstructorTransformer.kt @@ -42,7 +42,17 @@ class BackInTimeDebuggableConstructorTransformer : IrElementTransformerVoid() { if (!parentClass.isBackInTimeDebuggable) return declaration val irBuilder = irBuiltIns.createIrBuilder(declaration.symbol) - val registerCall = irBuilder.generateRegisterCall(parentClass) + + val registerCall = with(irBuilder) { + /** see [com.kitakkun.backintime.core.runtime.event.BackInTimeDebuggableInstanceEvent.RegisterTarget] */ + irCall(reportInstanceRegistrationFunctionSymbol).apply { + putValueArgument(0, irGet(parentClass.thisReceiver!!)) + putValueArgument(1, irString(parentClass.fqNameWhenAvailable?.asString() ?: "unknown")) + putValueArgument(2, irString(parentClass.superClass?.fqNameWhenAvailable?.asString() ?: "unknown")) + putValueArgument(3, generatePropertiesInfo(parentClass.properties)) + } + } + val propertyRelationshipResolveCalls = parentClass.properties .filter { it.isBackInTimeDebuggable && !it.isDelegated && !it.isVar } .mapNotNull { property -> @@ -62,14 +72,6 @@ class BackInTimeDebuggableConstructorTransformer : IrElementTransformerVoid() { return declaration } - /** see [com.kitakkun.backintime.core.runtime.event.BackInTimeDebuggableInstanceEvent.RegisterTarget] */ - private fun IrBuilderWithScope.generateRegisterCall(parentClass: IrClass) = irCall(reportInstanceRegistrationFunctionSymbol).apply { - putValueArgument(0, irGet(parentClass.thisReceiver!!)) - putValueArgument(1, irString(parentClass.fqNameWhenAvailable?.asString() ?: "unknown")) - putValueArgument(2, irString(parentClass.superClass?.fqNameWhenAvailable?.asString() ?: "unknown")) - putValueArgument(3, generatePropertiesInfo(parentClass.properties)) - } - private fun IrBuilderWithScope.generatePropertiesInfo( properties: Sequence, ) = irCall(listOfFunction).apply { diff --git a/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/utils/IrClassUtils.kt b/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/utils/IrClassUtils.kt deleted file mode 100644 index a46405f1..00000000 --- a/compiler/backend/src/main/core/com/kitakkun/backintime/compiler/backend/utils/IrClassUtils.kt +++ /dev/null @@ -1,19 +0,0 @@ -package com.kitakkun.backintime.compiler.backend.utils - -import org.jetbrains.kotlin.ir.declarations.IrClass -import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol -import org.jetbrains.kotlin.ir.types.classOrNull -import org.jetbrains.kotlin.ir.util.simpleFunctions -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.synthetic.isVisibleOutside - -fun IrClass.getSimpleFunctionsRecursively(name: Name): List { - return simpleFunctions().filter { it.name == name }.map { it.symbol } - .plus( - superTypes - .flatMap { it.classOrNull?.owner?.getSimpleFunctionsRecursively(name) ?: emptyList() } - .filter { - it.owner.visibility.isVisibleOutside() - }, - ) -} diff --git a/compiler/cli/src/main/core/com/kitakkun/backintime/compiler/cli/BackInTimeCompilerRegistrar.kt b/compiler/cli/src/main/core/com/kitakkun/backintime/compiler/cli/BackInTimeCompilerRegistrar.kt index 61d3ed31..840b1fbd 100644 --- a/compiler/cli/src/main/core/com/kitakkun/backintime/compiler/cli/BackInTimeCompilerRegistrar.kt +++ b/compiler/cli/src/main/core/com/kitakkun/backintime/compiler/cli/BackInTimeCompilerRegistrar.kt @@ -22,6 +22,6 @@ class BackInTimeCompilerRegistrar : CompilerPluginRegistrar() { MessageCollectorHolder.messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE) FirExtensionRegistrarAdapter.registerExtension(BackInTimeFirExtensionRegistrar()) - IrGenerationExtension.registerExtension(BackInTimeIrGenerationExtension(config)) + IrGenerationExtension.registerExtension(BackInTimeIrGenerationExtension()) } } diff --git a/compiler/common/src/main/core/com/kitakkun/backintime/compiler/common/BackInTimeConsts.kt b/compiler/common/src/main/core/com/kitakkun/backintime/compiler/common/BackInTimeConsts.kt index 852252dc..7971336d 100644 --- a/compiler/common/src/main/core/com/kitakkun/backintime/compiler/common/BackInTimeConsts.kt +++ b/compiler/common/src/main/core/com/kitakkun/backintime/compiler/common/BackInTimeConsts.kt @@ -7,7 +7,6 @@ import org.jetbrains.kotlin.name.Name object BackInTimeConsts { val backInTimeDebuggableInterfaceClassId = classId("com.kitakkun.backintime.core.runtime", "BackInTimeDebuggable") - val backInTimeDebuggableInterfaceClassFqName = backInTimeDebuggableInterfaceClassId.asSingleFqName() val serializeMethodName = Name.identifier("serializeValue") val deserializeMethodName = Name.identifier("deserializeValue") @@ -15,13 +14,6 @@ object BackInTimeConsts { val backInTimeInstanceUUIDName = Name.identifier("backInTimeInstanceUUID") val backInTimeInitializedPropertyMapName = Name.identifier("backInTimeInitializedPropertyMap") - val propertyInfoClassId = classId("com.kitakkun.backintime.core.websocket.event.model", "PropertyInfo") - val listOfFunctionId = CallableId(FqName("kotlin.collections"), Name.identifier("listOf")) - val UUIDClassId = classId("java.util", "UUID") - const val RANDOM_UUID_FUNCTION_NAME = "randomUUID" - // kotlinx.serialization val backInTimeJsonCallableId = CallableId(FqName("com.kitakkun.backintime.core.runtime"), Name.identifier("backInTimeJson")) - val kotlinxSerializationEncodeToStringCallableId = CallableId(FqName("kotlinx.serialization"), Name.identifier("encodeToString")) - val kotlinxSerializationDecodeFromStringCallableId = CallableId(FqName("kotlinx.serialization"), Name.identifier("decodeFromString")) } diff --git a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/BackInTimeFirExtensionRegistrar.kt b/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/BackInTimeFirExtensionRegistrar.kt index 362440f2..44cf73c3 100644 --- a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/BackInTimeFirExtensionRegistrar.kt +++ b/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/BackInTimeFirExtensionRegistrar.kt @@ -5,8 +5,6 @@ import com.kitakkun.backintime.compiler.k2.api.VersionSpecificAPIImpl import com.kitakkun.backintime.compiler.k2.checkers.BackInTimeFirAdditionalCheckersExtension import com.kitakkun.backintime.compiler.k2.extension.BackInTimeFirDeclarationGenerationExtension import com.kitakkun.backintime.compiler.k2.extension.BackInTimeFirSupertypeGenerationExtension -import com.kitakkun.backintime.compiler.k2.matcher.DebuggableStateHolderPredicateMatcher -import com.kitakkun.backintime.compiler.k2.matcher.ValueContainerPredicateMatcher import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar class BackInTimeFirExtensionRegistrar : FirExtensionRegistrar() { @@ -16,9 +14,6 @@ class BackInTimeFirExtensionRegistrar : FirExtensionRegistrar() { +::BackInTimeFirSupertypeGenerationExtension +::BackInTimeFirDeclarationGenerationExtension - +::DebuggableStateHolderPredicateMatcher - +::ValueContainerPredicateMatcher - +::BackInTimeFirAdditionalCheckersExtension } } diff --git a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/checkers/BackInTimeFirAdditionalCheckersExtension.kt b/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/checkers/BackInTimeFirAdditionalCheckersExtension.kt index a501b4d8..c14a4d8d 100644 --- a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/checkers/BackInTimeFirAdditionalCheckersExtension.kt +++ b/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/checkers/BackInTimeFirAdditionalCheckersExtension.kt @@ -1,12 +1,18 @@ package com.kitakkun.backintime.compiler.k2.checkers +import com.kitakkun.backintime.compiler.k2.predicate.ValueContainerPredicate import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker import org.jetbrains.kotlin.fir.analysis.extensions.FirAdditionalCheckersExtension +import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar class BackInTimeFirAdditionalCheckersExtension(session: FirSession) : FirAdditionalCheckersExtension(session) { override val declarationCheckers = object : DeclarationCheckers() { override val regularClassCheckers: Set = setOf(ValueContainerDefinitionChecker, DebuggableStateHolderPropertyChecker) } + + override fun FirDeclarationPredicateRegistrar.registerPredicates() { + register(ValueContainerPredicate) + } } diff --git a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/checkers/DebuggableStateHolderPropertyChecker.kt b/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/checkers/DebuggableStateHolderPropertyChecker.kt index 1b310050..a16d4c3e 100644 --- a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/checkers/DebuggableStateHolderPropertyChecker.kt +++ b/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/checkers/DebuggableStateHolderPropertyChecker.kt @@ -2,8 +2,8 @@ package com.kitakkun.backintime.compiler.k2.checkers import com.kitakkun.backintime.compiler.common.BackInTimeAnnotations import com.kitakkun.backintime.compiler.k2.api.VersionSpecificAPI -import com.kitakkun.backintime.compiler.k2.matcher.debuggableStateHolderPredicateMatcher -import com.kitakkun.backintime.compiler.k2.matcher.valueContainerPredicateMatcher +import com.kitakkun.backintime.compiler.k2.predicate.BackInTimePredicate +import com.kitakkun.backintime.compiler.k2.predicate.ValueContainerPredicate import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChe import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.hasAnnotation +import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.classId import org.jetbrains.kotlin.fir.types.coneType @@ -138,13 +139,17 @@ object DebuggableStateHolderPropertyChecker : FirRegularClassChecker(MppCheckerK context(CheckerContext) private fun ConeKotlinType.isValueContainer(): Boolean { // val predefinedInGradle = session.backInTimeCompilerConfigurationProvider.config.valueContainers.any { it.classId == this.classId } - val configuredViaAnnotation = VersionSpecificAPI.INSTANCE.resolveToRegularClassSymbol(this, session)?.let { session.valueContainerPredicateMatcher.isAnnotated(it) } ?: false + val configuredViaAnnotation = VersionSpecificAPI.INSTANCE.resolveToRegularClassSymbol(this, session)?.let { + session.predicateBasedProvider.matches(ValueContainerPredicate, it) + } ?: false // return predefinedInGradle || configuredViaAnnotation return configuredViaAnnotation } context(CheckerContext) private fun ConeKotlinType.isDebuggableStateHolder(): Boolean { - return VersionSpecificAPI.INSTANCE.resolveToRegularClassSymbol(this, session)?.let { session.debuggableStateHolderPredicateMatcher.isAnnotated(it) } ?: false + return VersionSpecificAPI.INSTANCE.resolveToRegularClassSymbol(this, session)?.let { + session.predicateBasedProvider.matches(BackInTimePredicate, it) + } ?: false } } diff --git a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/matcher/DebuggableStateHolderPredicateMatcher.kt b/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/matcher/DebuggableStateHolderPredicateMatcher.kt deleted file mode 100644 index 7d42c3db..00000000 --- a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/matcher/DebuggableStateHolderPredicateMatcher.kt +++ /dev/null @@ -1,16 +0,0 @@ -package com.kitakkun.backintime.compiler.k2.matcher - -import com.kitakkun.backintime.compiler.common.BackInTimeAnnotations -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate -import org.jetbrains.kotlin.fir.extensions.utils.AbstractSimpleClassPredicateMatchingService - -class DebuggableStateHolderPredicateMatcher( - session: FirSession, -) : AbstractSimpleClassPredicateMatchingService(session) { - override val predicate = DeclarationPredicate.create { - annotated(BackInTimeAnnotations.backInTimeAnnotationFqName) - } -} - -val FirSession.debuggableStateHolderPredicateMatcher: DebuggableStateHolderPredicateMatcher by FirSession.sessionComponentAccessor() diff --git a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/matcher/ValueContainerPredicateMatcher.kt b/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/matcher/ValueContainerPredicateMatcher.kt deleted file mode 100644 index 55b08145..00000000 --- a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/matcher/ValueContainerPredicateMatcher.kt +++ /dev/null @@ -1,16 +0,0 @@ -package com.kitakkun.backintime.compiler.k2.matcher - -import com.kitakkun.backintime.compiler.common.BackInTimeAnnotations -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate -import org.jetbrains.kotlin.fir.extensions.utils.AbstractSimpleClassPredicateMatchingService - -class ValueContainerPredicateMatcher( - session: FirSession, -) : AbstractSimpleClassPredicateMatchingService(session) { - override val predicate = DeclarationPredicate.create { - annotated(BackInTimeAnnotations.valueContainerAnnotationFqName) - } -} - -val FirSession.valueContainerPredicateMatcher: ValueContainerPredicateMatcher by FirSession.sessionComponentAccessor() diff --git a/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/predicate/ValueContainerPredicate.kt b/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/predicate/ValueContainerPredicate.kt new file mode 100644 index 00000000..2ff89e68 --- /dev/null +++ b/compiler/k2/src/main/core/com/kitakkun/backintime/compiler/k2/predicate/ValueContainerPredicate.kt @@ -0,0 +1,8 @@ +package com.kitakkun.backintime.compiler.k2.predicate + +import com.kitakkun.backintime.compiler.common.BackInTimeAnnotations +import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate + +val ValueContainerPredicate = DeclarationPredicate.create { + annotated(BackInTimeAnnotations.valueContainerAnnotationFqName) +}