From 2a297ed21d9f8bdf0e433563eb9e59e40e3e0a1f Mon Sep 17 00:00:00 2001 From: raulraja Date: Sat, 31 Dec 2022 13:33:41 +0100 Subject: [PATCH 1/8] Progress unfinished on reflect branch --- .../src/main/kotlin/MetaModule.kt | 9 + .../src/main/kotlin/arrow/meta/Meta.kt | 28 +- .../src/main/kotlin/arrow/meta/MetaContext.kt | 84 +- .../kotlin/arrow/meta/TemplateCompiler.kt | 51 +- .../arrow/meta/macros/DeclarationMacro.kt | 181 +++ .../kotlin/arrow/meta/macros/Transform.kt | 35 + .../main/kotlin/arrow/meta/module/Module.kt | 74 + .../meta/plugins/AssignmentTransformer.kt | 20 + .../kotlin/arrow/meta/plugins/Checkers.kt | 36 + .../arrow/meta/plugins/CompilerPlugin.kt | 5 + .../meta/plugins/ExpressionResolution.kt | 21 + .../arrow/meta/plugins/FrontendPlugin.kt | 34 + .../kotlin/arrow/meta/plugins/Generation.kt | 80 ++ .../arrow/meta/plugins/MetaFirTransformer.kt | 745 +++++++++++ .../meta/plugins/SAMConversionTransformer.kt | 20 + .../arrow/meta/plugins/ScriptConfigurator.kt | 20 + .../arrow/meta/plugins/StatusTransformer.kt | 24 + .../kotlin/arrow/meta/plugins/Supertypes.kt | 32 + .../kotlin/arrow/meta/plugins/Transformer.kt | 1192 +++++++++++++++++ .../arrow/meta/plugins/TypeAttributes.kt | 24 + .../arrow/meta/plugins/example/ExampleFull.kt | 77 ++ .../main/kotlin/arrow/meta/samples/Product.kt | 4 +- .../main/kotlin/arrow/meta/samples/Reflect.kt | 412 ++++++ .../fir/FirArrowReflectExtensionRegistrar.kt | 188 ++- .../FirMetaAdditionalCheckersExtension.kt | 3 +- .../CompilerPluginGenerationExtension.kt | 58 + .../fir/codegen/FirMetaCodegenExtension.kt | 72 +- .../fir/transformers/FirMetaTransformer.kt | 18 +- .../compiler/plugin/targets/MetaInvoke.kt | 8 + .../compiler/plugin/targets/MetaTarget.kt | 3 +- .../src/testData/box/reflect_test.fir.ir.txt | 172 +++ .../src/testData/box/reflect_test.fir.txt | 39 + .../src/testData/box/reflect_test.kt | 19 + .../plugin/runners/BoxTestGenerated.java | 6 + sandbox/src/main/kotlin/CallGraph.kt | 14 + 35 files changed, 3723 insertions(+), 85 deletions(-) create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/DeclarationMacro.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/Transform.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/AssignmentTransformer.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Checkers.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/CompilerPlugin.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ExpressionResolution.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/FrontendPlugin.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Generation.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/MetaFirTransformer.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/SAMConversionTransformer.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ScriptConfigurator.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/StatusTransformer.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Supertypes.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Transformer.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/TypeAttributes.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/example/ExampleFull.kt create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt create mode 100644 arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/CompilerPluginGenerationExtension.kt create mode 100644 arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.ir.txt create mode 100644 arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.txt create mode 100644 arrow-reflect-compiler-plugin/src/testData/box/reflect_test.kt create mode 100644 sandbox/src/main/kotlin/CallGraph.kt diff --git a/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt b/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt index 680ee27..2191503 100644 --- a/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt +++ b/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt @@ -1,13 +1,22 @@ package arrow.meta.module.impl +import arrow.meta.macros.MyMacro +import arrow.meta.module.Compiler import arrow.meta.module.Module +import arrow.meta.module.increment import arrow.meta.samples.* interface MetaModule: Module { + val reflect: Reflect val increment: Increment val product: Product val log: Log val decorator: Decorator val pure: Pure + val myMacro : MyMacro //val optics: Optics } + +interface MetaModule2: Module { + val increment get() = Compiler::increment +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Meta.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Meta.kt index a9f35e6..15e8039 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Meta.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Meta.kt @@ -100,33 +100,43 @@ annotation class Meta { sealed interface Members : Generate { interface Constructors : Members { - fun FirMetaContext.constructors(firClass: FirClass): Boolean - fun FirMetaContext.constructors(context: MemberGenerationContext): List + @OptIn(SymbolInternals::class) + fun FirMetaMemberGenerationContext.constructors(firClass: FirClassSymbol<*>): Set = + newConstructors(firClass.fir).keys.map { Name.identifier(it) }.toSet() + + @OptIn(SymbolInternals::class) + fun FirMetaMemberGenerationContext.constructors(callableId: CallableId, context: MemberGenerationContext): List { + val firClass = context.owner.fir + return newConstructors(firClass).values.map { it().constructor } + } + + fun FirMetaMemberGenerationContext.newConstructors(firClass: FirClass): Map String> } interface Functions : Members { @OptIn(SymbolInternals::class) - fun FirMetaContext.functions(firClass: FirClassSymbol<*>): Set = + fun FirMetaMemberGenerationContext.functions(firClass: FirClassSymbol<*>): Set = newFunctions(firClass.fir).keys.map { Name.identifier(it) }.toSet() @OptIn(SymbolInternals::class) - fun FirMetaContext.functions(callableId: CallableId, context: MemberGenerationContext): List { + fun FirMetaMemberGenerationContext.functions(callableId: CallableId, context: MemberGenerationContext): List { val firClass = context.owner.fir return newFunctions(firClass).values.map { it().function } } - fun FirMetaContext.newFunctions(firClass: FirClass): Map String> + fun FirMetaMemberGenerationContext.newFunctions(firClass: FirClass): Map String> } interface Properties : Members { - fun FirMetaContext.properties(firClass: FirClassSymbol<*>): Set - fun FirMetaContext.properties(callableId: CallableId, context: MemberGenerationContext): List + fun FirMetaMemberGenerationContext.properties(firClass: FirClassSymbol<*>): Set + fun FirMetaMemberGenerationContext.properties(callableId: CallableId, context: MemberGenerationContext): List } interface NestedClasses : Members { - fun FirMetaContext.nestedClasses(firClass: FirClassSymbol<*>): Set - fun FirMetaContext.nestedClasses(callableId: ClassId): List + fun FirMetaMemberGenerationContext.nestedClasses(firClass: FirClassSymbol<*>): Set + + fun FirMetaMemberGenerationContext.nestedClasses(classId: ClassId): List } } } diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/MetaContext.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/MetaContext.kt index 71d441e..254a861 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/MetaContext.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/MetaContext.kt @@ -1,5 +1,6 @@ package arrow.meta +import arrow.meta.macros.Kotlin import org.intellij.lang.annotations.Language import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities @@ -11,15 +12,21 @@ import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.builder.buildRegularClassCopy +import org.jetbrains.kotlin.fir.declarations.utils.addDeclaration +import org.jetbrains.kotlin.fir.declarations.utils.classId import org.jetbrains.kotlin.fir.expressions.FirCall import org.jetbrains.kotlin.fir.extensions.MemberGenerationContext import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.renderReadableWithFqNames import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.util.* +import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.text import kotlin.reflect.KClass @@ -61,6 +68,32 @@ abstract class FirMetaContext( abstract val scopeDeclarations: List + fun FirClass.addDeclarations(vararg declarations: FirDeclaration): FirClass { + val result = if (this is FirRegularClass) { + buildRegularClassCopy(this) { + declarations.forEach { + when (it) { + is FirRegularClass -> { + addDeclaration(buildRegularClassCopy(it) { + resolvePhase = FirResolvePhase.BODY_RESOLVE + symbol = FirRegularClassSymbol(ClassId.fromString(classId.asString() + "." + it.name.asString())) + }) + } + else -> {} + } + } + } + } else this + return result + } + + fun FirClassSymbol<*>.hasCompanion(): Boolean = this.companion() != null + + @OptIn(SymbolInternals::class) + fun FirClassSymbol<*>.companion(): FirClass? = + fir.declarations.filterIsInstance() + .firstOrNull { it.classId.shortClassName == Name.identifier("Companion") } + @OptIn(SymbolInternals::class) fun propertiesOf(firClass: FirClass, f: (FirValueParameter) -> String): String = +firClass.primaryConstructorIfAny(session)?.fir?.valueParameters.orEmpty().filter { it.isVal }.map { @@ -69,15 +102,33 @@ abstract class FirMetaContext( val String.function: FirSimpleFunction get() { - val results = templateCompiler.compileSource(this@FirMetaContext as? FirMetaCheckerContext, this, extendedAnalysisMode = false, scopeDeclarations) + val results = templateCompiler.compileSource( + this@FirMetaContext as? FirMetaCheckerContext, + this, + extendedAnalysisMode = false, + scopeDeclarations + ) val firFiles = results.firResults.flatMap { it.files } val currentElement: FirSimpleFunction? = findSelectedFirElement(FirSimpleFunction::class, firFiles) return currentElement ?: error("Could not find a ${FirSimpleFunction::class}") } + val String.constructor: FirConstructor + get() { + val results = templateCompiler.compileSource( + this@FirMetaContext as? FirMetaCheckerContext, + this, + extendedAnalysisMode = false, + scopeDeclarations + ) + val firFiles = results.firResults.flatMap { it.files } + val currentElement: FirConstructor? = findSelectedFirElement(FirConstructor::class, firFiles) + return currentElement ?: error("Could not find a ${FirSimpleFunction::class}") + } + operator fun FirElement.unaryPlus(): String = - source?.text?.toString() - ?: (this as? FirTypeRef)?.coneType?.renderReadableWithFqNames()?.replace("/", ".") + (this as? FirTypeRef)?.coneType?.renderReadableWithFqNames()?.replace("/", ".") + ?: source?.text?.toString() ?: error("$this has no source psi text element") val String.call: FirCall @@ -88,15 +139,31 @@ abstract class FirMetaContext( """ ) + fun source(@Language("kotlin") source: String): String = source + + inline fun kotlin(@Language("kotlin") value: String): Kotlin = + Kotlin(Out::class, value) + inline fun compile(@Language("kotlin") source: String): Fir { - val results = templateCompiler.compileSource(this@FirMetaContext as? FirMetaCheckerContext, source, extendedAnalysisMode = false, scopeDeclarations) + val results = templateCompiler.compileSource( + this@FirMetaContext as? FirMetaCheckerContext, + source, + extendedAnalysisMode = false, + scopeDeclarations + ) val firFiles = results.firResults.flatMap { it.files } val currentElement: Fir? = findSelectedFirElement(Fir::class, firFiles) - return currentElement ?: error("Could not find a ${Fir::class}") + return currentElement ?: errorNotFound(Fir::class) } + fun errorNotFound(fir: KClass): Nothing = + error("Could not find a ${fir::class}") + @PublishedApi - internal fun findSelectedFirElement(firElementClass: KClass, firFiles: List): Fir? { + internal fun findSelectedFirElement( + firElementClass: KClass, + firFiles: List + ): Fir? { var currentElement: Fir? = null firFiles.forEach { firFile -> firFile.accept(object : FirVisitorVoid() { @@ -123,7 +190,8 @@ class FirMetaCheckerContext( override val templateCompiler: TemplateCompiler, override val session: FirSession, val checkerContext: CheckerContext, - val diagnosticReporter: DiagnosticReporter + val diagnosticReporter: DiagnosticReporter, + val additionalContext: FirDeclaration? = null, ) : FirMetaContext(session, templateCompiler) { fun FirElement.report(factory: KtDiagnosticFactory1, msg: String) { @@ -137,7 +205,7 @@ class FirMetaCheckerContext( } override val scopeDeclarations: List - get() = checkerContext.containingDeclarations + get() = checkerContext.containingDeclarations + listOfNotNull(additionalContext) } class FirMetaMemberGenerationContext( diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/TemplateCompiler.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/TemplateCompiler.kt index ea69e67..cca7075 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/TemplateCompiler.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/TemplateCompiler.kt @@ -1,17 +1,16 @@ package arrow.meta +import com.intellij.psi.PsiDocumentManager +import com.intellij.psi.PsiFile import org.jetbrains.kotlin.KtIoFileSourceFile import org.jetbrains.kotlin.KtSourceFile import org.jetbrains.kotlin.backend.jvm.JvmIrDeserializerImpl -import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter import org.jetbrains.kotlin.cli.common.messages.* import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.* import org.jetbrains.kotlin.cli.common.modules.ModuleBuilder import org.jetbrains.kotlin.cli.jvm.compiler.* import org.jetbrains.kotlin.config.* -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory -import org.jetbrains.kotlin.diagnostics.DiagnosticUtils +import org.jetbrains.kotlin.diagnostics.* import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.analysis.collectors.FirDiagnosticsCollector @@ -20,19 +19,13 @@ import org.jetbrains.kotlin.fir.backend.jvm.JvmFir2IrExtensions import org.jetbrains.kotlin.fir.builder.BodyBuildingMode import org.jetbrains.kotlin.fir.builder.RawFirBuilder import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunctionCopy -import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation -import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression -import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotationArgumentMappingImpl import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir -import org.jetbrains.kotlin.fir.pipeline.buildFirViaLightTree import org.jetbrains.kotlin.fir.pipeline.convertToIr import org.jetbrains.kotlin.fir.resolve.* import org.jetbrains.kotlin.fir.resolve.calls.ImplicitDispatchReceiverValue import org.jetbrains.kotlin.fir.resolve.dfa.DataFlowAnalyzerContext import org.jetbrains.kotlin.fir.resolve.providers.firProvider import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl -import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider import org.jetbrains.kotlin.fir.resolve.transformers.* import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer @@ -47,24 +40,16 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope import org.jetbrains.kotlin.fir.scopes.impl.FirPackageMemberScope import org.jetbrains.kotlin.fir.scopes.kotlinScopeProvider import org.jetbrains.kotlin.fir.session.sourcesToPathsMapper +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.SymbolInternals -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.types.ConeLookupTagBasedType -import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.fir.visitors.FirTransformer +import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.incremental.createDirectory import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler import org.jetbrains.kotlin.modules.Module -import org.jetbrains.kotlin.name.CallableId -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus -import org.jetbrains.kotlin.psi import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.readSourceFileWithMapping -import org.jetbrains.kotlin.types.ConstantValueKind import java.io.File import java.util.concurrent.atomic.AtomicInteger @@ -117,11 +102,12 @@ class TemplateCompiler( try { val next = counter.incrementAndGet() val fileName = "meta.template_$next.kt" - println("parsing source:\n$source") + //println("parsing source:\n$source") println("session: ${session::class}") + val sourceFile = File(templatesFolder, fileName) val allSources = listOf( - File(templatesFolder, fileName).also { + sourceFile.also { it.writeText(source) } ) @@ -135,7 +121,7 @@ class TemplateCompiler( messageCollector, moduleConfiguration ) - val result = context.compileModule(metaCheckerContext, scopeDeclarations) + val result = context.compileModule(sourceFile, metaCheckerContext, scopeDeclarations) val templateResult = result ?: return TemplateResult(emptyList(), emptyList()) outputs += templateResult @@ -152,16 +138,21 @@ class TemplateCompiler( } } - private fun CompilationContext.compileModule(metaCheckerContext: FirMetaCheckerContext?, scopeDeclarations: List): FirResult? { + private fun CompilationContext.compileModule( + sourceFile: File, + metaCheckerContext: FirMetaCheckerContext?, + scopeDeclarations: List + ): FirResult? { ProgressIndicatorAndCompilationCanceledStatus.checkCanceled() - val renderDiagnosticNames = true val diagnosticsReporter = DiagnosticReporterFactory.createPendingReporter() val firResult = runFrontend(allSources, diagnosticsReporter, scopeDeclarations) - val diagnosticsContext = metaCheckerContext?.checkerContext - if (firResult == null && diagnosticsContext != null) { - diagnosticsReporter.diagnostics.forEach { - metaCheckerContext.diagnosticReporter.report(it, diagnosticsContext) - println("error: [" + it.factory.name + "] " + it.factory.ktRenderer.render(it)) + if (firResult == null) { + val (source, mappings) = sourceFile.inputStream().reader().use { it.readSourceFileWithMapping() } + diagnosticsReporter.diagnosticsByFilePath.entries.forEach { (path, diagnostics) -> + diagnostics.forEach { + val (line, column) = mappings.getLineAndColumnByOffset(it.element.startOffset) + println("error: file://${sourceFile.absolutePath}:$line:$column [" + it.factory.name + "] " + it.factory.ktRenderer.render(it)) + } } return null } diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/DeclarationMacro.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/DeclarationMacro.kt new file mode 100644 index 0000000..e282a1c --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/DeclarationMacro.kt @@ -0,0 +1,181 @@ +package arrow.meta.macros + +import arrow.meta.Meta +import arrow.meta.plugins.* +import org.jetbrains.kotlin.KtInMemoryTextSourceFile +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.extensions.AnnotationFqn +import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate +import org.jetbrains.kotlin.fir.extensions.predicate.LookupPredicate +import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider +import org.jetbrains.kotlin.fir.pipeline.buildFirViaLightTree +import org.jetbrains.kotlin.fir.resolve.fqName +import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals + +typealias ClassMacro = DeclarationMacro + +@OptIn(SymbolInternals::class) +abstract class DeclarationMacro(annotation: Annotation) : FrontendPlugin.Builder() { + + override val plugins: Sequence<(FirSession) -> FrontendPlugin> + get() { + return super.plugins + sequence { + yield( + Generation { + register(macroPredicate) + session.transformations.forEach { transformation -> + when (transformation) { + is Transform.Generate.Member.Function -> { + callableNamesForClass = { classSymbol -> + val kotlin = transformation.invoke(classSymbol.fir, null) + val fir = session.buildFirViaLightTree( + listOf( + KtInMemoryTextSourceFile( + "topLevelCallableIds.map.kt", null, kotlin.value + ) + ) + ) + val decls = fir.firstOrNull()?.declarations?.filterIsInstance() + ?.map { it.symbol.callableId.callableName } + decls?.toSet().orEmpty() + } + } + + is Transform.Generate.Member.NestedClass -> TODO() + is Transform.Generate.Member.Property -> TODO() + is Transform.Generate.TopLevel.Class -> TODO() + is Transform.Generate.TopLevel.Function -> TODO() + is Transform.Generate.TopLevel.Property -> TODO() + is Transform.Replace -> TODO() + } + } + } + ) + } + } +// init { +// +Supertypes { +// registerPredicates = register(macroPredicate) +// } +// +StatusTransformer { +// registerPredicates = register(macroPredicate) +// } +// +Transformer { +// registerPredicates = register(macroPredicate) +// } +// +Generation { +// registerPredicates = register(macroPredicate) +// session.transformations.forEach { t -> +// when (t) { +// is Transform.Generate.Member.Function -> { +// callableNamesForClass = { classSymbol -> +// val kotlin = t.invoke(classSymbol.fir, null) +// +// TODO() +// } +// } +// is Transform.Generate.Member.NestedClass -> TODO() +// is Transform.Generate.Member.Property -> TODO() +// is Transform.Generate.TopLevel.Class -> TODO() +// is Transform.Generate.TopLevel.Function -> TODO() +// is Transform.Generate.TopLevel.Property -> TODO() +// is Transform.Replace -> TODO() +// } +// } +// } +// } + + val annotationFqName = AnnotationFqn(annotation.annotationClass.java.canonicalName) + + val macroPredicate: DeclarationPredicate = DeclarationPredicate.create { + metaAnnotated(annotationFqName) + } + + fun FirSession.macroSymbols(): List> = + predicateBasedProvider.getSymbolsByPredicate(LookupPredicate.create { annotated(annotationFqName) }) + + fun FirSession.macroInstances(): List> = macroSymbols().mapNotNull { + val macroAnnotation = it.annotations.firstOrNull { it.fqName(this) == annotationFqName } + val companionFqName = + macroAnnotation?.annotationTypeRef?.toRegularClassSymbol(this)?.fir?.companionObjectSymbol?.classId?.asFqNameString() + val companionInstance = Class.forName(companionFqName).kotlin.objectInstance as? DeclarationMacro<*> + companionInstance as? DeclarationMacro + } + + val FirSession.transformations: List> + get() = + macroInstances().map { it.run { transform() } } + + + // transformations.forEach { transform -> +// when (transform) { +// is Transform.Generate -> +Generation { +// registerPredicates = register(macroPredicate) +// when (transform) { +// is Transform.Generate.Member -> TODO() +// is Transform.Generate.TopLevel -> { +// when (transform) { +// is Transform.Generate.TopLevel.Class -> { +// +// } +// +// is Transform.Generate.TopLevel.Function -> { +// topLevelCallableIds = { +//// val source = transform.invoke(null) +//// val fir = session.buildFirViaLightTree( +//// listOf( +//// KtInMemoryTextSourceFile( +//// "topLevelCallableIds.map.kt", null, source.value +//// ) +//// ) +//// ) +//// val decls = fir.firstOrNull()?.declarations?.filterIsInstance() +//// ?.map { it.symbol.callableId } +//// decls?.toSet().orEmpty() +// TODO() +// } +// functions = { callableId, memberGenerationContext -> +// TODO() +// } +// } +// +// is Transform.Generate.TopLevel.Property -> TODO() +// is Transform.Generate.Member.Function -> TODO() +// is Transform.Generate.Member.NestedClass -> TODO() +// is Transform.Generate.Member.Property -> TODO() +// } +// +// classLikeDeclaration = { +// TODO() +// } +// } +// } +// } +// +// is Transform.Replace -> TODO() +// } +// } + abstract fun transform(): Transform + +} + +@Meta +annotation class MyMacro { + + companion object : ClassMacro(MyMacro()) { + override fun transform(): Transform.Generate.Member.Function = + Transform.Generate.Member.Function { context, callableId -> + Kotlin( + """ + fun foo(): Unit = println("Hello, World!") + """ + ) + } + } +} + +@MyMacro +class Sample diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/Transform.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/Transform.kt new file mode 100644 index 0000000..b921224 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/Transform.kt @@ -0,0 +1,35 @@ +package arrow.meta.macros + +import org.intellij.lang.annotations.Language +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.declarations.FirClass +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirProperty +import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction +import org.jetbrains.kotlin.name.CallableId +import org.jetbrains.kotlin.name.ClassId +import kotlin.reflect.KClass + +data class Kotlin (val target: KClass, @Language("kotlin") val value: String) { + override fun toString(): String = + value +} + +inline fun Kotlin(@Language("kotlin") value: String): Kotlin = + Kotlin(E::class, value) + +sealed interface Transform { + class Replace(val invoke: (In) -> Kotlin) : Transform + sealed interface Generate : Transform { + sealed interface TopLevel : Generate { + class Class(val invoke: (In, ClassId?) -> Kotlin) : TopLevel + class Function(val invoke: (In, CallableId?) -> Kotlin) : TopLevel + class Property(val invoke: (In, CallableId?) -> Kotlin) : TopLevel + } + sealed interface Member : Generate { + class NestedClass(val invoke: (In, ClassId?) -> Kotlin) : Member + class Function(val invoke: (In, CallableId?) -> Kotlin) : Member + class Property(val invoke: (In, CallableId?) -> Kotlin) : Member + } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/module/Module.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/module/Module.kt index e4b973d..d662d1a 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/module/Module.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/module/Module.kt @@ -1,3 +1,77 @@ package arrow.meta.module +import arrow.meta.FirMetaCheckerContext +import arrow.meta.FirMetaContext +import arrow.meta.Meta +import org.jetbrains.kotlin.fir.FirAnnotationContainer +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction +import org.jetbrains.kotlin.fir.declarations.hasAnnotation +import org.jetbrains.kotlin.fir.expressions.FirConstExpression +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.types.ConstantValueKind + interface Module + +inline fun classId(): ClassId { + val klass = A::class + val packageName = klass.java.`package`.name + val shortName = klass.java.simpleName + val isLocal = klass.java.isLocalClass + return ClassId(FqName(packageName), FqName(shortName), isLocal) +} + +inline fun FirAnnotationContainer.annotatedWith(): Boolean = + annotations.hasAnnotation(classId()) + +fun interface Transform { + fun FirMetaContext.transform(element: In): Out +} + +@Target(AnnotationTarget.EXPRESSION, AnnotationTarget.VALUE_PARAMETER) +@Retention(AnnotationRetention.SOURCE) +annotation class Increment + +annotation class AnnotatedWith + +typealias Compiler = FirMetaContext + +//transform macro +@Meta +fun Compiler.increment(@AnnotatedWith constant: FirConstExpression<*>): FirStatement { + check(constant.kind == ConstantValueKind.Int) { + "@Increment only works in constant of type `Int`. found: ${constant.kind.asString}" + } + return compile("${constant} + 1") +} + +object IncrementMacroImpl : Module, Meta.FrontendTransformer.ConstExpression { + override fun FirMetaCheckerContext.constExpression(constExpression: FirConstExpression<*>): FirStatement = + increment(constExpression) +} + +annotation class Test + +@Test +data class Sample(val name: String) + +//generation macro +@Meta +fun Compiler.generationMacro(@Test firClassSymbol: FirClassSymbol<*>): List = + listOf( + compile(""" + fun test(): Unit {} + """.trimIndent()) + ) + +fun main() { + //val x = Sample("f").test() + println(@Increment 0) +} + + + + diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/AssignmentTransformer.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/AssignmentTransformer.kt new file mode 100644 index 0000000..335efea --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/AssignmentTransformer.kt @@ -0,0 +1,20 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment + + +interface AssignmentTransformer : FrontendPlugin { + fun transformVariableAssignment(variableAssignment: FirVariableAssignment): FirStatement? + class Builder(override val session: FirSession) : FrontendPlugin.Builder(), AssignmentTransformer { + var transformVariableAssignment: (FirVariableAssignment) -> FirStatement? = { it } + + override fun transformVariableAssignment(variableAssignment: FirVariableAssignment): FirStatement? = + this.transformVariableAssignment(variableAssignment) + } + + companion object { + operator fun invoke(init: Builder.() -> Unit): (FirSession) -> AssignmentTransformer = { Builder(it).apply(init) } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Checkers.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Checkers.kt new file mode 100644 index 0000000..f177f58 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Checkers.kt @@ -0,0 +1,36 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.types.FirTypeRef + +interface Checkers : FrontendPlugin { + fun interface Declaration { + fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter) + } + + fun interface Expression { + fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter) + } + + fun interface Type { + fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter) + } + + val declarationCheckers: Set> + val expressionCheckers: Set> + val typeCheckers: Set> + + class Builder(override val session: FirSession) : FrontendPlugin.Builder(), Checkers { + override val declarationCheckers: MutableSet> = mutableSetOf() + override val expressionCheckers: MutableSet> = mutableSetOf() + override val typeCheckers: MutableSet> = mutableSetOf() + } + + companion object { + operator fun invoke(init: Builder.() -> Unit): (FirSession) -> Checkers = { Builder(it).apply(init) } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/CompilerPlugin.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/CompilerPlugin.kt new file mode 100644 index 0000000..3674fd9 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/CompilerPlugin.kt @@ -0,0 +1,5 @@ +package arrow.meta.plugins + +interface CompilerPlugin + + diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ExpressionResolution.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ExpressionResolution.kt new file mode 100644 index 0000000..d061de4 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ExpressionResolution.kt @@ -0,0 +1,21 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.types.ConeKotlinType + +interface ExpressionResolution : FrontendPlugin { + fun addNewImplicitReceivers(functionCall: FirFunctionCall): List + + class Builder(override val session: FirSession) : ExpressionResolution, FrontendPlugin.Builder() { + + var newImplicitReceivers: (FirFunctionCall) -> List = { emptyList() } + + override fun addNewImplicitReceivers(functionCall: FirFunctionCall): List = + newImplicitReceivers(functionCall) + } + + companion object { + operator fun invoke(init: Builder.() -> Unit): (FirSession) -> ExpressionResolution = { Builder(it).apply(init) } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/FrontendPlugin.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/FrontendPlugin.kt new file mode 100644 index 0000000..e1486ee --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/FrontendPlugin.kt @@ -0,0 +1,34 @@ +package arrow.meta.plugins + +import arrow.meta.Meta +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.extensions.AnnotationFqn +import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar +import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate + +sealed interface FrontendPlugin : CompilerPlugin { + + val session : FirSession + + val metaAnnotatedPredicate: DeclarationPredicate + get() = DeclarationPredicate.create { metaAnnotated(AnnotationFqn(Meta::class.java.canonicalName)) } + + fun FirDeclarationPredicateRegistrar.registerPredicates() { + register(metaAnnotatedPredicate) + } + + open class Builder { + private var compilerPlugins: Sequence<(FirSession) -> FrontendPlugin> = sequenceOf() + operator fun ((FirSession) -> FrontendPlugin).unaryPlus() { + compilerPlugins += this + } + open val plugins: Sequence<(FirSession) -> FrontendPlugin> get() = compilerPlugins + + fun register(macroPredicate: DeclarationPredicate): FirDeclarationPredicateRegistrar.() -> Unit = { + register(macroPredicate) + } + } + companion object { + operator fun invoke(init: Builder.() -> Unit): Builder = Builder().apply(init) + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Generation.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Generation.kt new file mode 100644 index 0000000..7d2398d --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Generation.kt @@ -0,0 +1,80 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.extensions.MemberGenerationContext +import org.jetbrains.kotlin.fir.symbols.impl.* +import org.jetbrains.kotlin.name.CallableId +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name + +interface Generation : FrontendPlugin { + fun generateClassLikeDeclaration(classId: ClassId): FirClassLikeSymbol<*>? + fun generateConstructors(context: MemberGenerationContext): List + fun generateFunctions(callableId: CallableId, context: MemberGenerationContext?): List + fun generateProperties(callableId: CallableId, context: MemberGenerationContext?): List + fun getCallableNamesForClass(classSymbol: FirClassSymbol<*>): Set + fun getNestedClassifiersNames(classSymbol: FirClassSymbol<*>): Set + fun getTopLevelCallableIds(): Set + fun getTopLevelClassIds(): Set + fun hasPackage(packageFqName: FqName): Boolean + + class Builder(override val session: FirSession) : Generation, FrontendPlugin.Builder() { + var classLikeDeclaration: (ClassId) -> FirClassLikeSymbol<*>? = { null } + var constructors: (MemberGenerationContext) -> List = { emptyList() } + var functions: (CallableId, MemberGenerationContext?) -> List = + { _, _ -> emptyList() } + var properties: (CallableId, MemberGenerationContext?) -> List = { _, _ -> emptyList() } + var callableNamesForClass: (FirClassSymbol<*>) -> Set = { emptySet() } + var nestedClassifiersNames: (FirClassSymbol<*>) -> Set = { emptySet() } + var topLevelCallableIds: () -> Set = { emptySet() } + var topLevelClassIds: () -> Set = { emptySet() } + var containsPackage: (FqName) -> Boolean = { false } + override fun generateClassLikeDeclaration(classId: ClassId): FirClassLikeSymbol<*>? { + return classLikeDeclaration(classId) + } + + override fun generateConstructors(context: MemberGenerationContext): List { + return constructors(context) + } + + override fun generateFunctions( + callableId: CallableId, + context: MemberGenerationContext? + ): List { + return functions(callableId, context) + } + + override fun generateProperties( + callableId: CallableId, + context: MemberGenerationContext? + ): List { + return properties(callableId, context) + } + + override fun getCallableNamesForClass(classSymbol: FirClassSymbol<*>): Set { + return callableNamesForClass(classSymbol) + } + + override fun getNestedClassifiersNames(classSymbol: FirClassSymbol<*>): Set { + return nestedClassifiersNames(classSymbol) + } + + override fun getTopLevelCallableIds(): Set { + return topLevelCallableIds() + } + + override fun getTopLevelClassIds(): Set { + return topLevelClassIds() + } + + override fun hasPackage(packageFqName: FqName): Boolean { + return containsPackage(packageFqName) + } + } + + companion object { + operator fun invoke(init: Builder.() -> Unit): (FirSession) -> Generation = + { Builder(it).apply(init) } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/MetaFirTransformer.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/MetaFirTransformer.kt new file mode 100644 index 0000000..598206f --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/MetaFirTransformer.kt @@ -0,0 +1,745 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.fir.* +import org.jetbrains.kotlin.fir.contracts.* +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder +import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.references.* +import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.visitors.FirTransformer + +class MetaFirTransformer(val builder: Transformer) : FirTransformer() { + override fun transformElement(element: E, data: FirElement): E { + element.transformChildren(this, data) + return element + } + + override fun transformAnnotation(annotation: FirAnnotation, data: FirElement): FirStatement { + return builder.transformAnnotation(annotation, data) + } + + override fun transformAnnotationArgumentMapping( + annotationArgumentMapping: FirAnnotationArgumentMapping, + data: FirElement + ): FirAnnotationArgumentMapping { + return builder.transformAnnotationArgumentMapping(annotationArgumentMapping, data) + } + + override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: FirElement): FirStatement { + return builder.transformAnnotationCall(annotationCall, data) + } + + override fun transformAnnotationContainer( + annotationContainer: FirAnnotationContainer, + data: FirElement + ): FirAnnotationContainer { + return builder.transformAnnotationContainer(annotationContainer, data) + } + + override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: FirElement): FirStatement { + return builder.transformAnonymousFunction(anonymousFunction, data) + } + + override fun transformAnonymousFunctionExpression( + anonymousFunctionExpression: FirAnonymousFunctionExpression, + data: FirElement + ): FirStatement { + return builder.transformAnonymousFunctionExpression(anonymousFunctionExpression, data) + } + + override fun transformAnonymousInitializer( + anonymousInitializer: FirAnonymousInitializer, + data: FirElement + ): FirAnonymousInitializer { + return builder.transformAnonymousInitializer(anonymousInitializer, data) + } + + override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: FirElement): FirStatement { + return builder.transformAnonymousObject(anonymousObject, data) + } + + override fun transformAnonymousObjectExpression( + anonymousObjectExpression: FirAnonymousObjectExpression, + data: FirElement + ): FirStatement { + return builder.transformAnonymousObjectExpression(anonymousObjectExpression, data) + } + + override fun transformArgumentList(argumentList: FirArgumentList, data: FirElement): FirArgumentList { + return builder.transformArgumentList(argumentList, data) + } + + override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: FirElement): FirStatement { + return builder.transformArrayOfCall(arrayOfCall, data) + } + + override fun transformAssignmentOperatorStatement( + assignmentOperatorStatement: FirAssignmentOperatorStatement, + data: FirElement + ): FirStatement { + return builder.transformAssignmentOperatorStatement(assignmentOperatorStatement, data) + } + + override fun transformAugmentedArraySetCall( + augmentedArraySetCall: FirAugmentedArraySetCall, + data: FirElement + ): FirStatement { + return builder.transformAugmentedArraySetCall(augmentedArraySetCall, data) + } + + override fun transformBackingField(backingField: FirBackingField, data: FirElement): FirStatement { + return builder.transformBackingField(backingField, data) + } + + override fun transformBackingFieldReference( + backingFieldReference: FirBackingFieldReference, + data: FirElement + ): FirReference { + return builder.transformBackingFieldReference(backingFieldReference, data) + } + + override fun transformBinaryLogicExpression( + binaryLogicExpression: FirBinaryLogicExpression, + data: FirElement + ): FirStatement { + return builder.transformBinaryLogicExpression(binaryLogicExpression, data) + } + + override fun transformBlock(block: FirBlock, data: FirElement): FirStatement { + return builder.transformBlock(block, data) + } + + override fun transformBreakExpression(breakExpression: FirBreakExpression, data: FirElement): FirStatement { + return builder.transformBreakExpression(breakExpression, data) + } + + override fun transformCall(call: FirCall, data: FirElement): FirStatement { + return builder.transformCall(call, data) + } + + override fun transformCallableDeclaration( + callableDeclaration: FirCallableDeclaration, + data: FirElement + ): FirCallableDeclaration { + return builder.transformCallableDeclaration(callableDeclaration, data) + } + + override fun transformCallableReferenceAccess( + callableReferenceAccess: FirCallableReferenceAccess, + data: FirElement + ): FirStatement { + return builder.transformCallableReferenceAccess(callableReferenceAccess, data) + } + + override fun transformCatch(catch: FirCatch, data: FirElement): FirCatch { + return builder.transformCatch(catch, data) + } + + override fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: FirElement): FirStatement { + return builder.transformCheckNotNullCall(checkNotNullCall, data) + } + + override fun transformCheckedSafeCallSubject( + checkedSafeCallSubject: FirCheckedSafeCallSubject, + data: FirElement + ): FirStatement { + return builder.transformCheckedSafeCallSubject(checkedSafeCallSubject, data) + } + + override fun transformClass(klass: FirClass, data: FirElement): FirStatement { + return builder.transformClass(klass, data) + } + + override fun transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: FirElement): FirStatement { + return builder.transformClassLikeDeclaration(classLikeDeclaration, data) + } + + override fun transformClassReferenceExpression( + classReferenceExpression: FirClassReferenceExpression, + data: FirElement + ): FirStatement { + return builder.transformClassReferenceExpression(classReferenceExpression, data) + } + + override fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, data: FirElement): FirStatement { + return builder.transformComparisonExpression(comparisonExpression, data) + } + + override fun transformComponentCall(componentCall: FirComponentCall, data: FirElement): FirStatement { + return builder.transformComponentCall(componentCall, data) + } + + override fun transformConstExpression(constExpression: FirConstExpression, data: FirElement): FirStatement { + return builder.transformConstExpression(constExpression, data) + } + + override fun transformConstructor(constructor: FirConstructor, data: FirElement): FirStatement { + return builder.transformConstructor(constructor, data) + } + + override fun transformContextReceiver(contextReceiver: FirContextReceiver, data: FirElement): FirContextReceiver { + return builder.transformContextReceiver(contextReceiver, data) + } + + override fun transformContextReceiverArgumentListOwner( + contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, + data: FirElement + ): FirContextReceiverArgumentListOwner { + return builder.transformContextReceiverArgumentListOwner(contextReceiverArgumentListOwner, data) + } + + override fun transformContinueExpression(continueExpression: FirContinueExpression, data: FirElement): FirStatement { + return builder.transformContinueExpression(continueExpression, data) + } + + override fun transformContractDescription( + contractDescription: FirContractDescription, + data: FirElement + ): FirContractDescription { + return builder.transformContractDescription(contractDescription, data) + } + + override fun transformContractDescriptionOwner( + contractDescriptionOwner: FirContractDescriptionOwner, + data: FirElement + ): FirContractDescriptionOwner { + return builder.transformContractDescriptionOwner(contractDescriptionOwner, data) + } + + override fun transformControlFlowGraphOwner( + controlFlowGraphOwner: FirControlFlowGraphOwner, + data: FirElement + ): FirControlFlowGraphOwner { + return builder.transformControlFlowGraphOwner(controlFlowGraphOwner, data) + } + + override fun transformControlFlowGraphReference( + controlFlowGraphReference: FirControlFlowGraphReference, + data: FirElement + ): FirReference { + return builder.transformControlFlowGraphReference(controlFlowGraphReference, data) + } + + override fun transformDanglingModifierList( + danglingModifierList: FirDanglingModifierList, + data: FirElement + ): FirDanglingModifierList { + return builder.transformDanglingModifierList(danglingModifierList, data) + } + + override fun transformDeclaration(declaration: FirDeclaration, data: FirElement): FirDeclaration { + return builder.transformDeclaration(declaration, data) + } + + override fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: FirElement): FirDeclarationStatus { + return builder.transformDeclarationStatus(declarationStatus, data) + } + + override fun transformDelegateFieldReference( + delegateFieldReference: FirDelegateFieldReference, + data: FirElement + ): FirReference { + return builder.transformDelegateFieldReference(delegateFieldReference, data) + } + + override fun transformDelegatedConstructorCall( + delegatedConstructorCall: FirDelegatedConstructorCall, + data: FirElement + ): FirStatement { + return builder.transformDelegatedConstructorCall(delegatedConstructorCall, data) + } + + override fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: FirElement): FirDiagnosticHolder { + return builder.transformDiagnosticHolder(diagnosticHolder, data) + } + + override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: FirElement): FirStatement { + return builder.transformDoWhileLoop(doWhileLoop, data) + } + + override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: FirElement): FirTypeRef { + return builder.transformDynamicTypeRef(dynamicTypeRef, data) + } + + override fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: FirElement): FirEffectDeclaration { + return builder.transformEffectDeclaration(effectDeclaration, data) + } + + override fun transformElementWithResolvePhase( + elementWithResolvePhase: FirElementWithResolvePhase, + data: FirElement + ): FirElementWithResolvePhase { + return builder.transformElementWithResolvePhase(elementWithResolvePhase, data) + } + + override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: FirElement): FirStatement { + return builder.transformElvisExpression(elvisExpression, data) + } + + override fun transformEnumEntry(enumEntry: FirEnumEntry, data: FirElement): FirStatement { + return builder.transformEnumEntry(enumEntry, data) + } + + override fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: FirElement): FirStatement { + return builder.transformEqualityOperatorCall(equalityOperatorCall, data) + } + + override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: FirElement): FirStatement { + return builder.transformErrorAnnotationCall(errorAnnotationCall, data) + } + + override fun transformErrorExpression(errorExpression: FirErrorExpression, data: FirElement): FirStatement { + return builder.transformErrorExpression(errorExpression, data) + } + + override fun transformErrorFunction(errorFunction: FirErrorFunction, data: FirElement): FirStatement { + return builder.transformErrorFunction(errorFunction, data) + } + + override fun transformErrorImport(errorImport: FirErrorImport, data: FirElement): FirImport { + return builder.transformErrorImport(errorImport, data) + } + + override fun transformErrorLoop(errorLoop: FirErrorLoop, data: FirElement): FirStatement { + return builder.transformErrorLoop(errorLoop, data) + } + + override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: FirElement): FirReference { + return builder.transformErrorNamedReference(errorNamedReference, data) + } + + override fun transformErrorProperty(errorProperty: FirErrorProperty, data: FirElement): FirStatement { + return builder.transformErrorProperty(errorProperty, data) + } + + override fun transformErrorResolvedQualifier( + errorResolvedQualifier: FirErrorResolvedQualifier, + data: FirElement + ): FirStatement { + return builder.transformErrorResolvedQualifier(errorResolvedQualifier, data) + } + + override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: FirElement): FirTypeRef { + return builder.transformErrorTypeRef(errorTypeRef, data) + } + + override fun transformExpression(expression: FirExpression, data: FirElement): FirStatement { + return builder.transformExpression(expression, data) + } + + override fun transformField(field: FirField, data: FirElement): FirStatement { + return builder.transformField(field, data) + } + + override fun transformFile(file: FirFile, data: FirElement): FirFile { + return builder.transformFile(file, data) + } + + override fun transformFileAnnotationsContainer( + fileAnnotationsContainer: FirFileAnnotationsContainer, + data: FirElement + ): FirFileAnnotationsContainer { + return builder.transformFileAnnotationsContainer(fileAnnotationsContainer, data) + } + + override fun transformFunction(function: FirFunction, data: FirElement): FirStatement { + return builder.transformFunction(function, data) + } + + override fun transformFunctionCall(functionCall: FirFunctionCall, data: FirElement): FirStatement { + return builder.transformFunctionCall(functionCall, data) + } + + override fun transformFunctionTypeParameter( + functionTypeParameter: FirFunctionTypeParameter, + data: FirElement + ): FirFunctionTypeParameter { + return builder.transformFunctionTypeParameter(functionTypeParameter, data) + } + + override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: FirElement): FirTypeRef { + return builder.transformFunctionTypeRef(functionTypeRef, data) + } + + override fun transformGetClassCall(getClassCall: FirGetClassCall, data: FirElement): FirStatement { + return builder.transformGetClassCall(getClassCall, data) + } + + override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: FirElement): FirStatement { + return builder.transformImplicitInvokeCall(implicitInvokeCall, data) + } + + override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: FirElement): FirTypeRef { + return builder.transformImplicitTypeRef(implicitTypeRef, data) + } + + override fun transformImport(import: FirImport, data: FirElement): FirImport { + return builder.transformImport(import, data) + } + + override fun transformIntegerLiteralOperatorCall( + integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, + data: FirElement + ): FirStatement { + return builder.transformIntegerLiteralOperatorCall(integerLiteralOperatorCall, data) + } + + override fun transformIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, data: FirElement): FirTypeRef { + return builder.transformIntersectionTypeRef(intersectionTypeRef, data) + } + + override fun transformJump(jump: FirJump, data: FirElement): FirStatement { + return builder.transformJump(jump, data) + } + + override fun transformLabel(label: FirLabel, data: FirElement): FirLabel { + return builder.transformLabel(label, data) + } + + override fun transformLambdaArgumentExpression( + lambdaArgumentExpression: FirLambdaArgumentExpression, + data: FirElement + ): FirStatement { + return builder.transformLambdaArgumentExpression(lambdaArgumentExpression, data) + } + + override fun transformLegacyRawContractDescription( + legacyRawContractDescription: FirLegacyRawContractDescription, + data: FirElement + ): FirContractDescription { + return builder.transformLegacyRawContractDescription(legacyRawContractDescription, data) + } + + override fun transformLoop(loop: FirLoop, data: FirElement): FirStatement { + return builder.transformLoop(loop, data) + } + + override fun transformLoopJump(loopJump: FirLoopJump, data: FirElement): FirStatement { + return builder.transformLoopJump(loopJump, data) + } + + override fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: FirElement): FirMemberDeclaration { + return builder.transformMemberDeclaration(memberDeclaration, data) + } + + override fun transformNamedArgumentExpression( + namedArgumentExpression: FirNamedArgumentExpression, + data: FirElement + ): FirStatement { + return builder.transformNamedArgumentExpression(namedArgumentExpression, data) + } + + override fun transformNamedReference(namedReference: FirNamedReference, data: FirElement): FirReference { + return builder.transformNamedReference(namedReference, data) + } + + override fun transformNamedReferenceWithCandidateBase( + namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, + data: FirElement + ): FirReference { + return builder.transformNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase, data) + } + + override fun transformPackageDirective(packageDirective: FirPackageDirective, data: FirElement): FirPackageDirective { + return builder.transformPackageDirective(packageDirective, data) + } + + override fun transformPlaceholderProjection( + placeholderProjection: FirPlaceholderProjection, + data: FirElement + ): FirTypeProjection { + return builder.transformPlaceholderProjection(placeholderProjection, data) + } + + override fun transformProperty(property: FirProperty, data: FirElement): FirStatement { + return builder.transformProperty(property, data) + } + + override fun transformPropertyAccessExpression( + propertyAccessExpression: FirPropertyAccessExpression, + data: FirElement + ): FirStatement { + return builder.transformPropertyAccessExpression(propertyAccessExpression, data) + } + + override fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: FirElement): FirStatement { + return builder.transformPropertyAccessor(propertyAccessor, data) + } + + override fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: FirElement): FirStatement { + return builder.transformQualifiedAccess(qualifiedAccess, data) + } + + override fun transformQualifiedAccessExpression( + qualifiedAccessExpression: FirQualifiedAccessExpression, + data: FirElement + ): FirStatement { + return builder.transformQualifiedAccessExpression(qualifiedAccessExpression, data) + } + + override fun transformQualifiedErrorAccessExpression( + qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, + data: FirElement + ): FirStatement { + return builder.transformQualifiedErrorAccessExpression(qualifiedErrorAccessExpression, data) + } + + override fun transformRawContractDescription( + rawContractDescription: FirRawContractDescription, + data: FirElement + ): FirContractDescription { + return builder.transformRawContractDescription(rawContractDescription, data) + } + + override fun transformReceiverParameter(receiverParameter: FirReceiverParameter, data: FirElement): FirReceiverParameter { + return builder.transformReceiverParameter(receiverParameter, data) + } + + override fun transformReference(reference: FirReference, data: FirElement): FirReference { + return builder.transformReference(reference, data) + } + + override fun transformRegularClass(regularClass: FirRegularClass, data: FirElement): FirStatement { + return builder.transformRegularClass(regularClass, data) + } + + override fun transformResolvable(resolvable: FirResolvable, data: FirElement): FirResolvable { + return builder.transformResolvable(resolvable, data) + } + + override fun transformResolvedCallableReference( + resolvedCallableReference: FirResolvedCallableReference, + data: FirElement + ): FirReference { + return builder.transformResolvedCallableReference(resolvedCallableReference, data) + } + + override fun transformResolvedContractDescription( + resolvedContractDescription: FirResolvedContractDescription, + data: FirElement + ): FirContractDescription { + return builder.transformResolvedContractDescription(resolvedContractDescription, data) + } + + override fun transformResolvedDeclarationStatus( + resolvedDeclarationStatus: FirResolvedDeclarationStatus, + data: FirElement + ): FirDeclarationStatus { + return builder.transformResolvedDeclarationStatus(resolvedDeclarationStatus, data) + } + + override fun transformResolvedErrorReference( + resolvedErrorReference: FirResolvedErrorReference, + data: FirElement + ): FirReference { + return builder.transformResolvedErrorReference(resolvedErrorReference, data) + } + + override fun transformResolvedImport(resolvedImport: FirResolvedImport, data: FirElement): FirImport { + return builder.transformResolvedImport(resolvedImport, data) + } + + override fun transformResolvedNamedReference( + resolvedNamedReference: FirResolvedNamedReference, + data: FirElement + ): FirReference { + return builder.transformResolvedNamedReference(resolvedNamedReference, data) + } + + override fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: FirElement): FirStatement { + return builder.transformResolvedQualifier(resolvedQualifier, data) + } + + override fun transformResolvedReifiedParameterReference( + resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, + data: FirElement + ): FirStatement { + return builder.transformResolvedReifiedParameterReference(resolvedReifiedParameterReference, data) + } + + override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: FirElement): FirTypeRef { + return builder.transformResolvedTypeRef(resolvedTypeRef, data) + } + + override fun transformReturnExpression(returnExpression: FirReturnExpression, data: FirElement): FirStatement { + return builder.transformReturnExpression(returnExpression, data) + } + + override fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: FirElement): FirStatement { + return builder.transformSafeCallExpression(safeCallExpression, data) + } + + override fun transformScript(script: FirScript, data: FirElement): FirScript { + return builder.transformScript(script, data) + } + + override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: FirElement): FirStatement { + return builder.transformSimpleFunction(simpleFunction, data) + } + + override fun transformSmartCastExpression(smartCastExpression: FirSmartCastExpression, data: FirElement): FirStatement { + return builder.transformSmartCastExpression(smartCastExpression, data) + } + + override fun transformSpreadArgumentExpression( + spreadArgumentExpression: FirSpreadArgumentExpression, + data: FirElement + ): FirStatement { + return builder.transformSpreadArgumentExpression(spreadArgumentExpression, data) + } + + override fun transformStarProjection(starProjection: FirStarProjection, data: FirElement): FirTypeProjection { + return builder.transformStarProjection(starProjection, data) + } + + override fun transformStatement(statement: FirStatement, data: FirElement): FirStatement { + return builder.transformStatement(statement, data) + } + + override fun transformStringConcatenationCall( + stringConcatenationCall: FirStringConcatenationCall, + data: FirElement + ): FirStatement { + return builder.transformStringConcatenationCall(stringConcatenationCall, data) + } + + override fun transformSuperReference(superReference: FirSuperReference, data: FirElement): FirReference { + return builder.transformSuperReference(superReference, data) + } + + override fun transformTargetElement(targetElement: FirTargetElement, data: FirElement): FirTargetElement { + return builder.transformTargetElement(targetElement, data) + } + + override fun transformThisReceiverExpression( + thisReceiverExpression: FirThisReceiverExpression, + data: FirElement + ): FirStatement { + return builder.transformThisReceiverExpression(thisReceiverExpression, data) + } + + override fun transformThisReference(thisReference: FirThisReference, data: FirElement): FirReference { + return builder.transformThisReference(thisReference, data) + } + + override fun transformThrowExpression(throwExpression: FirThrowExpression, data: FirElement): FirStatement { + return builder.transformThrowExpression(throwExpression, data) + } + + override fun transformTryExpression(tryExpression: FirTryExpression, data: FirElement): FirStatement { + return builder.transformTryExpression(tryExpression, data) + } + + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: FirElement): FirStatement { + return builder.transformTypeAlias(typeAlias, data) + } + + override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: FirElement): FirStatement { + return builder.transformTypeOperatorCall(typeOperatorCall, data) + } + + override fun transformTypeParameter(typeParameter: FirTypeParameter, data: FirElement): FirTypeParameterRef { + return builder.transformTypeParameter(typeParameter, data) + } + + override fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: FirElement): FirTypeParameterRef { + return builder.transformTypeParameterRef(typeParameterRef, data) + } + + override fun transformTypeParameterRefsOwner( + typeParameterRefsOwner: FirTypeParameterRefsOwner, + data: FirElement + ): FirTypeParameterRefsOwner { + return builder.transformTypeParameterRefsOwner(typeParameterRefsOwner, data) + } + + override fun transformTypeParametersOwner( + typeParametersOwner: FirTypeParametersOwner, + data: FirElement + ): FirTypeParametersOwner { + return builder.transformTypeParametersOwner(typeParametersOwner, data) + } + + override fun transformTypeProjection(typeProjection: FirTypeProjection, data: FirElement): FirTypeProjection { + return builder.transformTypeProjection(typeProjection, data) + } + + override fun transformTypeProjectionWithVariance( + typeProjectionWithVariance: FirTypeProjectionWithVariance, + data: FirElement + ): FirTypeProjection { + return builder.transformTypeProjectionWithVariance(typeProjectionWithVariance, data) + } + + override fun transformTypeRef(typeRef: FirTypeRef, data: FirElement): FirTypeRef { + return builder.transformTypeRef(typeRef, data) + } + + override fun transformTypeRefWithNullability( + typeRefWithNullability: FirTypeRefWithNullability, + data: FirElement + ): FirTypeRef { + return builder.transformTypeRefWithNullability(typeRefWithNullability, data) + } + + override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: FirElement): FirTypeRef { + return builder.transformUserTypeRef(userTypeRef, data) + } + + override fun transformValueParameter(valueParameter: FirValueParameter, data: FirElement): FirStatement { + return builder.transformValueParameter(valueParameter, data) + } + + override fun transformVarargArgumentsExpression( + varargArgumentsExpression: FirVarargArgumentsExpression, + data: FirElement + ): FirStatement { + return builder.transformVarargArgumentsExpression(varargArgumentsExpression, data) + } + + override fun transformVariable(variable: FirVariable, data: FirElement): FirStatement { + return builder.transformVariable(variable, data) + } + + override fun transformVariableAssignment(variableAssignment: FirVariableAssignment, data: FirElement): FirStatement { + return builder.transformVariableAssignment(variableAssignment, data) + } + + override fun transformWhenBranch(whenBranch: FirWhenBranch, data: FirElement): FirWhenBranch { + return builder.transformWhenBranch(whenBranch, data) + } + + override fun transformWhenExpression(whenExpression: FirWhenExpression, data: FirElement): FirStatement { + return builder.transformWhenExpression(whenExpression, data) + } + + override fun transformWhenSubjectExpression( + whenSubjectExpression: FirWhenSubjectExpression, + data: FirElement + ): FirStatement { + return builder.transformWhenSubjectExpression(whenSubjectExpression, data) + } + + override fun transformWhileLoop(whileLoop: FirWhileLoop, data: FirElement): FirStatement { + return builder.transformWhileLoop(whileLoop, data) + } + + override fun transformWrappedArgumentExpression( + wrappedArgumentExpression: FirWrappedArgumentExpression, + data: FirElement + ): FirStatement { + return builder.transformWrappedArgumentExpression(wrappedArgumentExpression, data) + } + + override fun transformWrappedDelegateExpression( + wrappedDelegateExpression: FirWrappedDelegateExpression, + data: FirElement + ): FirStatement { + return builder.transformWrappedDelegateExpression(wrappedDelegateExpression, data) + } + + override fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, data: FirElement): FirStatement { + return builder.transformWrappedExpression(wrappedExpression, data) + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/SAMConversionTransformer.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/SAMConversionTransformer.kt new file mode 100644 index 0000000..c3757e9 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/SAMConversionTransformer.kt @@ -0,0 +1,20 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction +import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType + +interface SAMConversionTransformer : FrontendPlugin { + fun getCustomFunctionalTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? + class Builder(override val session: FirSession) : SAMConversionTransformer, FrontendPlugin.Builder() { + + var getCustomFunctionalTypeForSamConversion: (FirSimpleFunction) -> ConeLookupTagBasedType? = { null } + + override fun getCustomFunctionalTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? = + this.getCustomFunctionalTypeForSamConversion(function) + } + + companion object { + operator fun invoke(init: Builder.() -> Unit): (FirSession) -> SAMConversionTransformer = { Builder(it).apply(init) } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ScriptConfigurator.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ScriptConfigurator.kt new file mode 100644 index 0000000..60c8660 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ScriptConfigurator.kt @@ -0,0 +1,20 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.builder.FirFileBuilder +import org.jetbrains.kotlin.fir.declarations.builder.FirScriptBuilder + +interface ScriptConfigurator : FrontendPlugin { + fun FirScriptBuilder.configure(fileBuilder: FirFileBuilder) + class Builder(override val session: FirSession) : ScriptConfigurator, FrontendPlugin.Builder() { + var configureScript: FirScriptBuilder.(FirFileBuilder) -> Unit = {} + + override fun FirScriptBuilder.configure(fileBuilder: FirFileBuilder) { + configureScript(fileBuilder) + } + } + + companion object { + operator fun invoke(init: Builder.() -> Unit): (FirSession) -> ScriptConfigurator = { Builder(it).apply(init) } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/StatusTransformer.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/StatusTransformer.kt new file mode 100644 index 0000000..7634924 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/StatusTransformer.kt @@ -0,0 +1,24 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus + +interface StatusTransformer : FrontendPlugin { + abstract fun needTransformStatus(declaration: FirDeclaration): Boolean + + fun transformStatus(status: FirDeclarationStatus, declaration: FirDeclaration): FirDeclarationStatus = status + + class Builder(override val session: FirSession) : StatusTransformer, FrontendPlugin.Builder() { + var shouldTransformStatus: (FirDeclaration) -> Boolean = { false } + var transformStatus: (FirDeclarationStatus) -> FirDeclarationStatus = { it } + + override fun needTransformStatus(declaration: FirDeclaration): Boolean { + return shouldTransformStatus(declaration) + } + } + + companion object { + operator fun invoke(init: Builder.() -> Unit): (FirSession) -> StatusTransformer = { Builder(it).apply(init) } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Supertypes.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Supertypes.kt new file mode 100644 index 0000000..a932598 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Supertypes.kt @@ -0,0 +1,32 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.extensions.FirSupertypeGenerationExtension +import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef + +interface Supertypes : FrontendPlugin { + context(FirSupertypeGenerationExtension.TypeResolveServiceContainer) fun computeAdditionalSupertypes( + classLikeDeclaration: FirClassLikeDeclaration, resolvedSupertypes: List + ): List + + fun needTransformSupertypes(declaration: FirClassLikeDeclaration): Boolean + + class Builder(override val session: FirSession) : Supertypes, FrontendPlugin.Builder() { + var additionalSupertypes: (FirClassLikeDeclaration, List) -> List = + { _, _ -> emptyList() } + var shouldTransformSupertypes: (FirClassLikeDeclaration) -> Boolean = { false } + override fun computeAdditionalSupertypes( + classLikeDeclaration: FirClassLikeDeclaration, + resolvedSupertypes: List + ): List = + additionalSupertypes(classLikeDeclaration, resolvedSupertypes) + + override fun needTransformSupertypes(declaration: FirClassLikeDeclaration): Boolean = + shouldTransformSupertypes(declaration) + } + + companion object { + operator fun invoke(init: Builder.() -> Unit): (FirSession) -> Supertypes = { Builder(it).apply(init) } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Transformer.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Transformer.kt new file mode 100644 index 0000000..cee12e2 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Transformer.kt @@ -0,0 +1,1192 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.fir.* +import org.jetbrains.kotlin.fir.contracts.* +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder +import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.references.* +import org.jetbrains.kotlin.fir.types.* + +interface Transformer : FrontendPlugin { + + fun transformAnnotationContainer(annotationContainer: FirAnnotationContainer, parent: FirElement): FirAnnotationContainer + + fun transformTypeRef(typeRef: FirTypeRef, parent: FirElement): FirTypeRef + + fun transformReference(reference: FirReference, parent: FirElement): FirReference + + fun transformLabel(label: FirLabel, parent: FirElement): FirLabel + + fun transformResolvable(resolvable: FirResolvable, parent: FirElement): FirResolvable + + fun transformTargetElement(targetElement: FirTargetElement, parent: FirElement): FirTargetElement + + fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, parent: FirElement): FirDeclarationStatus + + fun transformResolvedDeclarationStatus( + resolvedDeclarationStatus: FirResolvedDeclarationStatus, + parent: FirElement + ): FirDeclarationStatus + + fun transformControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, parent: FirElement): FirControlFlowGraphOwner + + fun transformStatement(statement: FirStatement, parent: FirElement): FirStatement + + fun transformExpression(expression: FirExpression, parent: FirElement): FirStatement + + fun transformContextReceiver(contextReceiver: FirContextReceiver, parent: FirElement): FirContextReceiver + + fun transformElementWithResolvePhase( + elementWithResolvePhase: FirElementWithResolvePhase, + parent: FirElement + ): FirElementWithResolvePhase + + fun transformFileAnnotationsContainer( + fileAnnotationsContainer: FirFileAnnotationsContainer, + parent: FirElement + ): FirFileAnnotationsContainer + + fun transformDeclaration(declaration: FirDeclaration, parent: FirElement): FirDeclaration + + fun transformTypeParameterRefsOwner( + typeParameterRefsOwner: FirTypeParameterRefsOwner, + parent: FirElement + ): FirTypeParameterRefsOwner + + fun transformTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, parent: FirElement): FirTypeParametersOwner + + fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, parent: FirElement): FirMemberDeclaration + + fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, parent: FirElement): FirAnonymousInitializer + + fun transformCallableDeclaration(callableDeclaration: FirCallableDeclaration, parent: FirElement): FirCallableDeclaration + + fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, parent: FirElement): FirTypeParameterRef + + fun transformTypeParameter(typeParameter: FirTypeParameter, parent: FirElement): FirTypeParameterRef + + fun transformVariable(variable: FirVariable, parent: FirElement): FirStatement + + fun transformValueParameter(valueParameter: FirValueParameter, parent: FirElement): FirStatement + + fun transformReceiverParameter(receiverParameter: FirReceiverParameter, parent: FirElement): FirReceiverParameter + + fun transformProperty(property: FirProperty, parent: FirElement): FirStatement + + fun transformField(field: FirField, parent: FirElement): FirStatement + + fun transformEnumEntry(enumEntry: FirEnumEntry, parent: FirElement): FirStatement + + fun transformFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter, parent: FirElement): FirFunctionTypeParameter + + fun transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, parent: FirElement): FirStatement + + fun transformClass(klass: FirClass, parent: FirElement): FirStatement + + fun transformRegularClass(regularClass: FirRegularClass, parent: FirElement): FirStatement + + fun transformTypeAlias(typeAlias: FirTypeAlias, parent: FirElement): FirStatement + + fun transformFunction(function: FirFunction, parent: FirElement): FirStatement + + fun transformContractDescriptionOwner( + contractDescriptionOwner: FirContractDescriptionOwner, + parent: FirElement + ): FirContractDescriptionOwner + + fun transformSimpleFunction(simpleFunction: FirSimpleFunction, parent: FirElement): FirStatement + + fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, parent: FirElement): FirStatement + + fun transformBackingField(backingField: FirBackingField, parent: FirElement): FirStatement + + fun transformConstructor(constructor: FirConstructor, parent: FirElement): FirStatement + + fun transformFile(file: FirFile, parent: FirElement): FirFile + + fun transformScript(script: FirScript, parent: FirElement): FirScript + + fun transformPackageDirective(packageDirective: FirPackageDirective, parent: FirElement): FirPackageDirective + + fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, parent: FirElement): FirStatement + + fun transformAnonymousFunctionExpression( + anonymousFunctionExpression: FirAnonymousFunctionExpression, + parent: FirElement + ): FirStatement + + fun transformAnonymousObject(anonymousObject: FirAnonymousObject, parent: FirElement): FirStatement + + fun transformAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression, parent: FirElement): FirStatement + + fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, parent: FirElement): FirDiagnosticHolder + + fun transformImport(import: FirImport, parent: FirElement): FirImport + + fun transformResolvedImport(resolvedImport: FirResolvedImport, parent: FirElement): FirImport + + fun transformErrorImport(errorImport: FirErrorImport, parent: FirElement): FirImport + + fun transformLoop(loop: FirLoop, parent: FirElement): FirStatement + + fun transformErrorLoop(errorLoop: FirErrorLoop, parent: FirElement): FirStatement + + fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, parent: FirElement): FirStatement + + fun transformWhileLoop(whileLoop: FirWhileLoop, parent: FirElement): FirStatement + + fun transformBlock(block: FirBlock, parent: FirElement): FirStatement + + fun transformBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, parent: FirElement): FirStatement + + fun transformJump(jump: FirJump, parent: FirElement): FirStatement + + fun transformLoopJump(loopJump: FirLoopJump, parent: FirElement): FirStatement + + fun transformBreakExpression(breakExpression: FirBreakExpression, parent: FirElement): FirStatement + + fun transformContinueExpression(continueExpression: FirContinueExpression, parent: FirElement): FirStatement + + fun transformCatch(catch: FirCatch, parent: FirElement): FirCatch + + fun transformTryExpression(tryExpression: FirTryExpression, parent: FirElement): FirStatement + + fun transformConstExpression(constExpression: FirConstExpression, parent: FirElement): FirStatement + + fun transformTypeProjection(typeProjection: FirTypeProjection, parent: FirElement): FirTypeProjection + + fun transformStarProjection(starProjection: FirStarProjection, parent: FirElement): FirTypeProjection + + fun transformPlaceholderProjection(placeholderProjection: FirPlaceholderProjection, parent: FirElement): FirTypeProjection + + fun transformTypeProjectionWithVariance( + typeProjectionWithVariance: FirTypeProjectionWithVariance, + parent: FirElement + ): FirTypeProjection + + fun transformArgumentList(argumentList: FirArgumentList, parent: FirElement): FirArgumentList + + fun transformCall(call: FirCall, parent: FirElement): FirStatement + + fun transformAnnotation(annotation: FirAnnotation, parent: FirElement): FirStatement + + fun transformAnnotationCall(annotationCall: FirAnnotationCall, parent: FirElement): FirStatement + + fun transformAnnotationArgumentMapping( + annotationArgumentMapping: FirAnnotationArgumentMapping, + parent: FirElement + ): FirAnnotationArgumentMapping + + fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, parent: FirElement): FirStatement + + fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, parent: FirElement): FirStatement + + fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, parent: FirElement): FirStatement + + fun transformAssignmentOperatorStatement( + assignmentOperatorStatement: FirAssignmentOperatorStatement, + parent: FirElement + ): FirStatement + + fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, parent: FirElement): FirStatement + + fun transformWhenExpression(whenExpression: FirWhenExpression, parent: FirElement): FirStatement + + fun transformWhenBranch(whenBranch: FirWhenBranch, parent: FirElement): FirWhenBranch + + fun transformContextReceiverArgumentListOwner( + contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, + parent: FirElement + ): FirContextReceiverArgumentListOwner + + fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, parent: FirElement): FirStatement + + fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, parent: FirElement): FirStatement + + fun transformElvisExpression(elvisExpression: FirElvisExpression, parent: FirElement): FirStatement + + fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, parent: FirElement): FirStatement + + fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, parent: FirElement): FirStatement + + fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, parent: FirElement): FirStatement + + fun transformErrorExpression(errorExpression: FirErrorExpression, parent: FirElement): FirStatement + + fun transformErrorFunction(errorFunction: FirErrorFunction, parent: FirElement): FirStatement + + fun transformErrorProperty(errorProperty: FirErrorProperty, parent: FirElement): FirStatement + + fun transformDanglingModifierList(danglingModifierList: FirDanglingModifierList, parent: FirElement): FirDanglingModifierList + + fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, parent: FirElement): FirStatement + + fun transformQualifiedErrorAccessExpression( + qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, + parent: FirElement + ): FirStatement + + fun transformPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression, parent: FirElement): FirStatement + + fun transformFunctionCall(functionCall: FirFunctionCall, parent: FirElement): FirStatement + + fun transformIntegerLiteralOperatorCall( + integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, + parent: FirElement + ): FirStatement + + fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, parent: FirElement): FirStatement + + fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, parent: FirElement): FirStatement + + fun transformComponentCall(componentCall: FirComponentCall, parent: FirElement): FirStatement + + fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, parent: FirElement): FirStatement + + fun transformThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, parent: FirElement): FirStatement + + fun transformSmartCastExpression(smartCastExpression: FirSmartCastExpression, parent: FirElement): FirStatement + + fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, parent: FirElement): FirStatement + + fun transformCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, parent: FirElement): FirStatement + + fun transformGetClassCall(getClassCall: FirGetClassCall, parent: FirElement): FirStatement + + fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, parent: FirElement): FirStatement + + fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, parent: FirElement): FirStatement + + fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, parent: FirElement): FirStatement + + fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, parent: FirElement): FirStatement + + fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, parent: FirElement): FirStatement + + fun transformVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, parent: FirElement): FirStatement + + fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, parent: FirElement): FirStatement + + fun transformErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, parent: FirElement): FirStatement + + fun transformResolvedReifiedParameterReference( + resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, + parent: FirElement + ): FirStatement + + fun transformReturnExpression(returnExpression: FirReturnExpression, parent: FirElement): FirStatement + + fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, parent: FirElement): FirStatement + + fun transformThrowExpression(throwExpression: FirThrowExpression, parent: FirElement): FirStatement + + fun transformVariableAssignment(variableAssignment: FirVariableAssignment, parent: FirElement): FirStatement + + fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, parent: FirElement): FirStatement + + fun transformWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, parent: FirElement): FirStatement + + fun transformNamedReference(namedReference: FirNamedReference, parent: FirElement): FirReference + + fun transformNamedReferenceWithCandidateBase( + namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, + parent: FirElement + ): FirReference + + fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, parent: FirElement): FirReference + + fun transformSuperReference(superReference: FirSuperReference, parent: FirElement): FirReference + + fun transformThisReference(thisReference: FirThisReference, parent: FirElement): FirReference + + fun transformControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, parent: FirElement): FirReference + + fun transformResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, parent: FirElement): FirReference + + fun transformResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference, parent: FirElement): FirReference + + fun transformDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, parent: FirElement): FirReference + + fun transformBackingFieldReference(backingFieldReference: FirBackingFieldReference, parent: FirElement): FirReference + + fun transformResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, parent: FirElement): FirReference + + fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, parent: FirElement): FirTypeRef + + fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, parent: FirElement): FirTypeRef + + fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, parent: FirElement): FirTypeRef + + fun transformUserTypeRef(userTypeRef: FirUserTypeRef, parent: FirElement): FirTypeRef + + fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, parent: FirElement): FirTypeRef + + fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, parent: FirElement): FirTypeRef + + fun transformIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, parent: FirElement): FirTypeRef + + fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, parent: FirElement): FirTypeRef + + fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, parent: FirElement): FirEffectDeclaration + + fun transformContractDescription(contractDescription: FirContractDescription, parent: FirElement): FirContractDescription + + fun transformLegacyRawContractDescription( + legacyRawContractDescription: FirLegacyRawContractDescription, + parent: FirElement + ): FirContractDescription + + fun transformRawContractDescription( + rawContractDescription: FirRawContractDescription, + parent: FirElement + ): FirContractDescription + + fun transformResolvedContractDescription( + resolvedContractDescription: FirResolvedContractDescription, + parent: FirElement + ): FirContractDescription + + class Builder(override val session: FirSession) : Transformer, FrontendPlugin.Builder() { + var annotationContainer: (FirAnnotationContainer, parent: FirElement) -> FirAnnotationContainer = { el, _ -> el } + + override fun transformAnnotationContainer( + annotationContainer: FirAnnotationContainer, + parent: FirElement + ): FirAnnotationContainer = + annotationContainer(annotationContainer, parent) + + var typeRef: (typeRef: FirTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } + + override fun transformTypeRef(typeRef: FirTypeRef, parent: FirElement): FirTypeRef = + typeRef(typeRef, parent) + + var typeProjection: (typeProjection: FirTypeProjection, parent: FirElement) -> FirTypeProjection = { el, _ -> el } + + override fun transformTypeProjection(typeProjection: FirTypeProjection, parent: FirElement): FirTypeProjection = + typeProjection(typeProjection, parent) + + var typeProjectionWithVariance: (typeProjectionWithVariance: FirTypeProjectionWithVariance, parent: FirElement) -> FirTypeProjectionWithVariance = + { el, _ -> el } + + override fun transformTypeProjectionWithVariance( + typeProjectionWithVariance: FirTypeProjectionWithVariance, + parent: FirElement + ): FirTypeProjectionWithVariance = + typeProjectionWithVariance(typeProjectionWithVariance, parent) + + var starProjection: (starProjection: FirStarProjection, parent: FirElement) -> FirStarProjection = { el, _ -> el } + + override fun transformStarProjection(starProjection: FirStarProjection, parent: FirElement): FirStarProjection = + starProjection(starProjection, parent) + + var reference: (reference: FirReference, parent: FirElement) -> FirReference = { el, _ -> el } + override fun transformReference(reference: FirReference, parent: FirElement): FirReference = + reference(reference, parent) + + var label: (label: FirLabel, parent: FirElement) -> FirLabel = { el, _ -> el } + override fun transformLabel(label: FirLabel, parent: FirElement): FirLabel = + label(label, parent) + + var resolvable: (resolvable: FirResolvable, parent: FirElement) -> FirResolvable = { el, _ -> el } + override fun transformResolvable(resolvable: FirResolvable, parent: FirElement): FirResolvable = + resolvable(resolvable, parent) + + var targetElement: (targetElement: FirTargetElement, parent: FirElement) -> FirTargetElement = { el, _ -> el } + override fun transformTargetElement(targetElement: FirTargetElement, parent: FirElement): FirTargetElement = + targetElement(targetElement, parent) + + var declarationStatus: (declarationStatus: FirDeclarationStatus, parent: FirElement) -> FirDeclarationStatus = { el, _ -> el } + override fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, parent: FirElement): FirDeclarationStatus = + declarationStatus(declarationStatus, parent) + + var resolvedDeclarationStatus: (resolvedDeclarationStatus: FirResolvedDeclarationStatus, parent: FirElement) -> FirDeclarationStatus = + { el, _ -> el } + + override fun transformResolvedDeclarationStatus( + resolvedDeclarationStatus: FirResolvedDeclarationStatus, + parent: FirElement + ): FirDeclarationStatus = + resolvedDeclarationStatus(resolvedDeclarationStatus, parent) + + var controlFlowGraphOwner: (controlFlowGraphOwner: FirControlFlowGraphOwner, parent: FirElement) -> FirControlFlowGraphOwner = + { el, _ -> el } + + override fun transformControlFlowGraphOwner( + controlFlowGraphOwner: FirControlFlowGraphOwner, + parent: FirElement + ): FirControlFlowGraphOwner = + controlFlowGraphOwner(controlFlowGraphOwner, parent) + + var statement: (statement: FirStatement, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformStatement(statement: FirStatement, parent: FirElement): FirStatement = + statement(statement, parent) + + var expression: (expression: FirExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformExpression(expression: FirExpression, parent: FirElement): FirStatement = + expression(expression, parent) + + var contextReceiver: (contextReceiver: FirContextReceiver, parent: FirElement) -> FirContextReceiver = { el, _ -> el } + override fun transformContextReceiver(contextReceiver: FirContextReceiver, parent: FirElement): FirContextReceiver = + contextReceiver(contextReceiver, parent) + + var elementWithResolvePhase: (elementWithResolvePhase: FirElementWithResolvePhase, parent: FirElement) -> FirElementWithResolvePhase = + { el, _ -> el } + + override fun transformElementWithResolvePhase( + elementWithResolvePhase: FirElementWithResolvePhase, + parent: FirElement + ): FirElementWithResolvePhase = + elementWithResolvePhase(elementWithResolvePhase, parent) + + var fileAnnotationsContainer: (fileAnnotationsContainer: FirFileAnnotationsContainer, parent: FirElement) -> FirFileAnnotationsContainer = + { el, _ -> el } + + override fun transformFileAnnotationsContainer( + fileAnnotationsContainer: FirFileAnnotationsContainer, + parent: FirElement + ): FirFileAnnotationsContainer = + fileAnnotationsContainer(fileAnnotationsContainer, parent) + + var declaration: (declaration: FirDeclaration, parent: FirElement) -> FirDeclaration = { el, _ -> el } + override fun transformDeclaration(declaration: FirDeclaration, parent: FirElement): FirDeclaration = + declaration(declaration, parent) + + var typeParameterRefsOwner: (typeParameterRefsOwner: FirTypeParameterRefsOwner, parent: FirElement) -> FirTypeParameterRefsOwner = + { el, _ -> el } + + override fun transformTypeParameterRefsOwner( + typeParameterRefsOwner: FirTypeParameterRefsOwner, + parent: FirElement + ): FirTypeParameterRefsOwner = + typeParameterRefsOwner(typeParameterRefsOwner, parent) + + var typeParametersOwner: (typeParametersOwner: FirTypeParametersOwner, parent: FirElement) -> FirTypeParametersOwner = + { el, _ -> el } + + override fun transformTypeParametersOwner( + typeParametersOwner: FirTypeParametersOwner, + parent: FirElement + ): FirTypeParametersOwner = + typeParametersOwner(typeParametersOwner, parent) + + var memberDeclaration: (memberDeclaration: FirMemberDeclaration, parent: FirElement) -> FirMemberDeclaration = { el, _ -> el } + override fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, parent: FirElement): FirMemberDeclaration = + memberDeclaration(memberDeclaration, parent) + + var anonymousInitializer: (anonymousInitializer: FirAnonymousInitializer, parent: FirElement) -> FirAnonymousInitializer = + { el, _ -> el } + + override fun transformAnonymousInitializer( + anonymousInitializer: FirAnonymousInitializer, + parent: FirElement + ): FirAnonymousInitializer = + anonymousInitializer(anonymousInitializer, parent) + + var callableDeclaration: (callableDeclaration: FirCallableDeclaration, parent: FirElement) -> FirCallableDeclaration = + { el, _ -> el } + + override fun transformCallableDeclaration( + callableDeclaration: FirCallableDeclaration, + parent: FirElement + ): FirCallableDeclaration = + callableDeclaration(callableDeclaration, parent) + + var typeParameterRef: (typeParameterRef: FirTypeParameterRef, parent: FirElement) -> FirTypeParameterRef = { el, _ -> el } + override fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, parent: FirElement): FirTypeParameterRef = + typeParameterRef(typeParameterRef, parent) + + var typeParameter: (typeParameter: FirTypeParameter, parent: FirElement) -> FirTypeParameterRef = { el, _ -> el } + override fun transformTypeParameter(typeParameter: FirTypeParameter, parent: FirElement): FirTypeParameterRef = + typeParameter(typeParameter, parent) + + var variable: (variable: FirVariable, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformVariable(variable: FirVariable, parent: FirElement): FirStatement = + variable(variable, parent) + + var valueParameter: (valueParameter: FirValueParameter, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformValueParameter(valueParameter: FirValueParameter, parent: FirElement): FirStatement = + valueParameter(valueParameter, parent) + + var receiverParameter: (receiverParameter: FirReceiverParameter, parent: FirElement) -> FirReceiverParameter = { el, _ -> el } + override fun transformReceiverParameter(receiverParameter: FirReceiverParameter, parent: FirElement): FirReceiverParameter = + receiverParameter(receiverParameter, parent) + + var property: (property: FirProperty, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformProperty(property: FirProperty, parent: FirElement): FirStatement = + property(property, parent) + + var field: (field: FirField, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformField(field: FirField, parent: FirElement): FirStatement = + field(field, parent) + + var enumEntry: (enumEntry: FirEnumEntry, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformEnumEntry(enumEntry: FirEnumEntry, parent: FirElement): FirStatement = + enumEntry(enumEntry, parent) + + var functionTypeParameter: (functionTypeParameter: FirFunctionTypeParameter, parent: FirElement) -> FirFunctionTypeParameter = + { el, _ -> el } + + override fun transformFunctionTypeParameter( + functionTypeParameter: FirFunctionTypeParameter, + parent: FirElement + ): FirFunctionTypeParameter = + functionTypeParameter(functionTypeParameter, parent) + + var classLikeDeclaration: (classLikeDeclaration: FirClassLikeDeclaration, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, parent: FirElement): FirStatement = + classLikeDeclaration(classLikeDeclaration, parent) + + var klass: (klass: FirClass, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformClass(klass: FirClass, parent: FirElement): FirStatement = + klass(klass, parent) + + var regularClass: (regularClass: FirRegularClass, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformRegularClass(regularClass: FirRegularClass, parent: FirElement): FirStatement = + regularClass(regularClass, parent) + + var typeAlias: (typeAlias: FirTypeAlias, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformTypeAlias(typeAlias: FirTypeAlias, parent: FirElement): FirStatement = + typeAlias(typeAlias, parent) + + var function: (function: FirFunction, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformFunction(function: FirFunction, parent: FirElement): FirStatement = + function(function, parent) + + var contractDescriptionOwner: (contractDescriptionOwner: FirContractDescriptionOwner, parent: FirElement) -> FirContractDescriptionOwner = + { el, _ -> el } + + override fun transformContractDescriptionOwner( + contractDescriptionOwner: FirContractDescriptionOwner, + parent: FirElement + ): FirContractDescriptionOwner = + contractDescriptionOwner(contractDescriptionOwner, parent) + + var simpleFunction: (simpleFunction: FirSimpleFunction, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, parent: FirElement): FirStatement = + simpleFunction(simpleFunction, parent) + + var propertyAccessor: (propertyAccessor: FirPropertyAccessor, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, parent: FirElement): FirStatement = + propertyAccessor(propertyAccessor, parent) + + var backingField: (backingField: FirBackingField, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformBackingField(backingField: FirBackingField, parent: FirElement): FirStatement = + backingField(backingField, parent) + + var constructor: (constructor: FirConstructor, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformConstructor(constructor: FirConstructor, parent: FirElement): FirStatement = + constructor(constructor, parent) + + var file: (file: FirFile, parent: FirElement) -> FirFile = { el, _ -> el } + override fun transformFile(file: FirFile, parent: FirElement): FirFile = + file(file, parent) + + var script: (script: FirScript, parent: FirElement) -> FirScript = { el, _ -> el } + override fun transformScript(script: FirScript, parent: FirElement): FirScript = + script(script, parent) + + var packageDirective: (packageDirective: FirPackageDirective, parent: FirElement) -> FirPackageDirective = { el, _ -> el } + override fun transformPackageDirective(packageDirective: FirPackageDirective, parent: FirElement): FirPackageDirective = + packageDirective(packageDirective, parent) + + var anonymousFunction: (anonymousFunction: FirAnonymousFunction, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, parent: FirElement): FirStatement = + anonymousFunction(anonymousFunction, parent) + + var anonymousFunctionExpression: (anonymousFunctionExpression: FirAnonymousFunctionExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformAnonymousFunctionExpression( + anonymousFunctionExpression: FirAnonymousFunctionExpression, + parent: FirElement + ): FirStatement = + anonymousFunctionExpression(anonymousFunctionExpression, parent) + + var anonymousObject: (anonymousObject: FirAnonymousObject, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, parent: FirElement): FirStatement = + anonymousObject(anonymousObject, parent) + + var anonymousObjectExpression: (anonymousObjectExpression: FirAnonymousObjectExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformAnonymousObjectExpression( + anonymousObjectExpression: FirAnonymousObjectExpression, + parent: FirElement + ): FirStatement = + anonymousObjectExpression(anonymousObjectExpression, parent) + + var diagnosticHolder: (diagnosticHolder: FirDiagnosticHolder, parent: FirElement) -> FirDiagnosticHolder = { el, _ -> el } + override fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, parent: FirElement): FirDiagnosticHolder = + diagnosticHolder(diagnosticHolder, parent) + + var import: (import: FirImport, parent: FirElement) -> FirImport = { el, _ -> el } + override fun transformImport(import: FirImport, parent: FirElement): FirImport = + import(import, parent) + + var resolvedImport: (resolvedImport: FirResolvedImport, parent: FirElement) -> FirImport = { el, _ -> el } + override fun transformResolvedImport(resolvedImport: FirResolvedImport, parent: FirElement): FirImport = + resolvedImport(resolvedImport, parent) + + var errorImport: (errorImport: FirErrorImport, parent: FirElement) -> FirImport = { el, _ -> el } + override fun transformErrorImport(errorImport: FirErrorImport, parent: FirElement): FirImport = + errorImport(errorImport, parent) + + var loop: (loop: FirLoop, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformLoop(loop: FirLoop, parent: FirElement): FirStatement = + loop(loop, parent) + + var errorLoop: (errorLoop: FirErrorLoop, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformErrorLoop(errorLoop: FirErrorLoop, parent: FirElement): FirStatement = + errorLoop(errorLoop, parent) + + var doWhileLoop: (doWhileLoop: FirDoWhileLoop, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, parent: FirElement): FirStatement = + doWhileLoop(doWhileLoop, parent) + + var whileLoop: (whileLoop: FirWhileLoop, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformWhileLoop(whileLoop: FirWhileLoop, parent: FirElement): FirStatement = + whileLoop(whileLoop, parent) + + var block: (block: FirBlock, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformBlock(block: FirBlock, parent: FirElement): FirStatement = + block(block, parent) + + var binaryLogicExpression: (binaryLogicExpression: FirBinaryLogicExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformBinaryLogicExpression( + binaryLogicExpression: FirBinaryLogicExpression, + parent: FirElement + ): FirStatement = + binaryLogicExpression(binaryLogicExpression, parent) + + var jump: (jump: FirJump<*>, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformJump(jump: FirJump, parent: FirElement): FirStatement = + jump(jump, parent) + + var loopJump: (loopJump: FirLoopJump, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformLoopJump(loopJump: FirLoopJump, parent: FirElement): FirStatement = + loopJump(loopJump, parent) + + var breakExpression: (breakExpression: FirBreakExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformBreakExpression(breakExpression: FirBreakExpression, parent: FirElement): FirStatement = + breakExpression(breakExpression, parent) + + var continueExpression: (continueExpression: FirContinueExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformContinueExpression(continueExpression: FirContinueExpression, parent: FirElement): FirStatement = + continueExpression(continueExpression, parent) + + var catch: (catch: FirCatch, parent: FirElement) -> FirCatch = { el, _ -> el } + override fun transformCatch(catch: FirCatch, parent: FirElement): FirCatch = + catch(catch, parent) + + var tryExpression: (tryExpression: FirTryExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformTryExpression(tryExpression: FirTryExpression, parent: FirElement): FirStatement = + tryExpression(tryExpression, parent) + + var constExpression: (constExpression: FirConstExpression<*>, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformConstExpression(constExpression: FirConstExpression, parent: FirElement): FirStatement = + constExpression(constExpression, parent) + + var placeholderProjection: (placeholderProjection: FirPlaceholderProjection, parent: FirElement) -> FirTypeProjection = + { el, _ -> el } + + override fun transformPlaceholderProjection( + placeholderProjection: FirPlaceholderProjection, + parent: FirElement + ): FirTypeProjection = + placeholderProjection(placeholderProjection, parent) + + var argumentList: (argumentList: FirArgumentList, parent: FirElement) -> FirArgumentList = { el, _ -> el } + override fun transformArgumentList(argumentList: FirArgumentList, parent: FirElement): FirArgumentList = + argumentList(argumentList, parent) + + var call: (call: FirCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformCall(call: FirCall, parent: FirElement): FirStatement = + call(call, parent) + + var annotation: (annotation: FirAnnotation, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformAnnotation(annotation: FirAnnotation, parent: FirElement): FirStatement = + annotation(annotation, parent) + + var annotationCall: (annotationCall: FirAnnotationCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformAnnotationCall(annotationCall: FirAnnotationCall, parent: FirElement): FirStatement = + annotationCall(annotationCall, parent) + + var annotationArgumentMapping: (annotationArgumentMapping: FirAnnotationArgumentMapping, parent: FirElement) -> FirAnnotationArgumentMapping = + { el, _ -> el } + + override fun transformAnnotationArgumentMapping( + annotationArgumentMapping: FirAnnotationArgumentMapping, + parent: FirElement + ): FirAnnotationArgumentMapping = + annotationArgumentMapping(annotationArgumentMapping, parent) + + var errorAnnotationCall: (errorAnnotationCall: FirErrorAnnotationCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, parent: FirElement): FirStatement = + errorAnnotationCall(errorAnnotationCall, parent) + + var comparisonExpression: (comparisonExpression: FirComparisonExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, parent: FirElement): FirStatement = + comparisonExpression(comparisonExpression, parent) + + var typeOperatorCall: (typeOperatorCall: FirTypeOperatorCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, parent: FirElement): FirStatement = + typeOperatorCall(typeOperatorCall, parent) + + var assignmentOperatorStatement: (assignmentOperatorStatement: FirAssignmentOperatorStatement, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformAssignmentOperatorStatement( + assignmentOperatorStatement: FirAssignmentOperatorStatement, + parent: FirElement + ): FirStatement = + assignmentOperatorStatement(assignmentOperatorStatement, parent) + + var equalityOperatorCall: (equalityOperatorCall: FirEqualityOperatorCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, parent: FirElement): FirStatement = + equalityOperatorCall(equalityOperatorCall, parent) + + var whenExpression: (whenExpression: FirWhenExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformWhenExpression(whenExpression: FirWhenExpression, parent: FirElement): FirStatement = + whenExpression(whenExpression, parent) + + var whenBranch: (whenBranch: FirWhenBranch, parent: FirElement) -> FirWhenBranch = { el, _ -> el } + override fun transformWhenBranch(whenBranch: FirWhenBranch, parent: FirElement): FirWhenBranch = + whenBranch(whenBranch, parent) + + var contextReceiverArgumentListOwner: (contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, parent: FirElement) -> FirContextReceiverArgumentListOwner = + { el, _ -> el } + + override fun transformContextReceiverArgumentListOwner( + contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, + parent: FirElement + ): FirContextReceiverArgumentListOwner = + contextReceiverArgumentListOwner(contextReceiverArgumentListOwner, parent) + + var qualifiedAccess: (qualifiedAccess: FirQualifiedAccess, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, parent: FirElement): FirStatement = + qualifiedAccess(qualifiedAccess, parent) + + var checkNotNullCall: (checkNotNullCall: FirCheckNotNullCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, parent: FirElement): FirStatement = + checkNotNullCall(checkNotNullCall, parent) + + var elvisExpression: (elvisExpression: FirElvisExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformElvisExpression(elvisExpression: FirElvisExpression, parent: FirElement): FirStatement = + elvisExpression(elvisExpression, parent) + + var arrayOfCall: (arrayOfCall: FirArrayOfCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, parent: FirElement): FirStatement = + arrayOfCall(arrayOfCall, parent) + + var augmentedArraySetCall: (augmentedArraySetCall: FirAugmentedArraySetCall, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformAugmentedArraySetCall( + augmentedArraySetCall: FirAugmentedArraySetCall, + parent: FirElement + ): FirStatement = + augmentedArraySetCall(augmentedArraySetCall, parent) + + var classReferenceExpression: (classReferenceExpression: FirClassReferenceExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformClassReferenceExpression( + classReferenceExpression: FirClassReferenceExpression, + parent: FirElement + ): FirStatement = + classReferenceExpression(classReferenceExpression, parent) + + var errorExpression: (errorExpression: FirErrorExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformErrorExpression(errorExpression: FirErrorExpression, parent: FirElement): FirStatement = + errorExpression(errorExpression, parent) + + var errorFunction: (errorFunction: FirErrorFunction, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformErrorFunction(errorFunction: FirErrorFunction, parent: FirElement): FirStatement = + errorFunction(errorFunction, parent) + + var errorProperty: (errorProperty: FirErrorProperty, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformErrorProperty(errorProperty: FirErrorProperty, parent: FirElement): FirStatement = + errorProperty(errorProperty, parent) + + var danglingModifierList: (danglingModifierList: FirDanglingModifierList, parent: FirElement) -> FirDanglingModifierList = + { el, _ -> el } + + override fun transformDanglingModifierList( + danglingModifierList: FirDanglingModifierList, + parent: FirElement + ): FirDanglingModifierList = + danglingModifierList(danglingModifierList, parent) + + var qualifiedAccessExpression: (qualifiedAccessExpression: FirQualifiedAccessExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformQualifiedAccessExpression( + qualifiedAccessExpression: FirQualifiedAccessExpression, + parent: FirElement + ): FirStatement = + qualifiedAccessExpression(qualifiedAccessExpression, parent) + + var qualifiedErrorAccessExpression: (qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformQualifiedErrorAccessExpression( + qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, + parent: FirElement + ): FirStatement = + qualifiedErrorAccessExpression(qualifiedErrorAccessExpression, parent) + + var propertyAccessExpression: (propertyAccessExpression: FirPropertyAccessExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformPropertyAccessExpression( + propertyAccessExpression: FirPropertyAccessExpression, + parent: FirElement + ): FirStatement = + propertyAccessExpression(propertyAccessExpression, parent) + + var functionCall: (functionCall: FirFunctionCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformFunctionCall(functionCall: FirFunctionCall, parent: FirElement): FirStatement = + functionCall(functionCall, parent) + + var integerLiteralOperatorCall: (integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformIntegerLiteralOperatorCall( + integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, + parent: FirElement + ): FirStatement = + integerLiteralOperatorCall(integerLiteralOperatorCall, parent) + + var implicitInvokeCall: (implicitInvokeCall: FirImplicitInvokeCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, parent: FirElement): FirStatement = + implicitInvokeCall(implicitInvokeCall, parent) + + var delegatedConstructorCall: (delegatedConstructorCall: FirDelegatedConstructorCall, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformDelegatedConstructorCall( + delegatedConstructorCall: FirDelegatedConstructorCall, + parent: FirElement + ): FirStatement = + delegatedConstructorCall(delegatedConstructorCall, parent) + + var componentCall: (componentCall: FirComponentCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformComponentCall(componentCall: FirComponentCall, parent: FirElement): FirStatement = + componentCall(componentCall, parent) + + var callableReferenceAccess: (callableReferenceAccess: FirCallableReferenceAccess, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformCallableReferenceAccess( + callableReferenceAccess: FirCallableReferenceAccess, + parent: FirElement + ): FirStatement = + callableReferenceAccess(callableReferenceAccess, parent) + + var thisReceiverExpression: (thisReceiverExpression: FirThisReceiverExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformThisReceiverExpression( + thisReceiverExpression: FirThisReceiverExpression, + parent: FirElement + ): FirStatement = + thisReceiverExpression(thisReceiverExpression, parent) + + var smartCastExpression: (smartCastExpression: FirSmartCastExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformSmartCastExpression(smartCastExpression: FirSmartCastExpression, parent: FirElement): FirStatement = + smartCastExpression(smartCastExpression, parent) + + var safeCallExpression: (safeCallExpression: FirSafeCallExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, parent: FirElement): FirStatement = + safeCallExpression(safeCallExpression, parent) + + var checkedSafeCallSubject: (checkedSafeCallSubject: FirCheckedSafeCallSubject, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformCheckedSafeCallSubject( + checkedSafeCallSubject: FirCheckedSafeCallSubject, + parent: FirElement + ): FirStatement = + checkedSafeCallSubject(checkedSafeCallSubject, parent) + + var getClassCall: (getClassCall: FirGetClassCall, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformGetClassCall(getClassCall: FirGetClassCall, parent: FirElement): FirStatement = + getClassCall(getClassCall, parent) + + var wrappedExpression: (wrappedExpression: FirWrappedExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, parent: FirElement): FirStatement = + wrappedExpression(wrappedExpression, parent) + + var wrappedArgumentExpression: (wrappedArgumentExpression: FirWrappedArgumentExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformWrappedArgumentExpression( + wrappedArgumentExpression: FirWrappedArgumentExpression, + parent: FirElement + ): FirStatement = + wrappedArgumentExpression(wrappedArgumentExpression, parent) + + var lambdaArgumentExpression: (lambdaArgumentExpression: FirLambdaArgumentExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformLambdaArgumentExpression( + lambdaArgumentExpression: FirLambdaArgumentExpression, + parent: FirElement + ): FirStatement = + lambdaArgumentExpression(lambdaArgumentExpression, parent) + + var spreadArgumentExpression: (spreadArgumentExpression: FirSpreadArgumentExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformSpreadArgumentExpression( + spreadArgumentExpression: FirSpreadArgumentExpression, + parent: FirElement + ): FirStatement = + spreadArgumentExpression(spreadArgumentExpression, parent) + + var namedArgumentExpression: (namedArgumentExpression: FirNamedArgumentExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformNamedArgumentExpression( + namedArgumentExpression: FirNamedArgumentExpression, + parent: FirElement + ): FirStatement = + namedArgumentExpression(namedArgumentExpression, parent) + + var varargArgumentsExpression: (varargArgumentsExpression: FirVarargArgumentsExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformVarargArgumentsExpression( + varargArgumentsExpression: FirVarargArgumentsExpression, + parent: FirElement + ): FirStatement = + varargArgumentsExpression(varargArgumentsExpression, parent) + + var resolvedQualifier: (resolvedQualifier: FirResolvedQualifier, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, parent: FirElement): FirStatement = + resolvedQualifier(resolvedQualifier, parent) + + var errorResolvedQualifier: (errorResolvedQualifier: FirErrorResolvedQualifier, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformErrorResolvedQualifier( + errorResolvedQualifier: FirErrorResolvedQualifier, + parent: FirElement + ): FirStatement = + errorResolvedQualifier(errorResolvedQualifier, parent) + + var resolvedReifiedParameterReference: (resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformResolvedReifiedParameterReference( + resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, + parent: FirElement + ): FirStatement = + resolvedReifiedParameterReference(resolvedReifiedParameterReference, parent) + + var returnExpression: (returnExpression: FirReturnExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformReturnExpression(returnExpression: FirReturnExpression, parent: FirElement): FirStatement = + returnExpression(returnExpression, parent) + + var stringConcatenationCall: (stringConcatenationCall: FirStringConcatenationCall, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformStringConcatenationCall( + stringConcatenationCall: FirStringConcatenationCall, + parent: FirElement + ): FirStatement = + stringConcatenationCall(stringConcatenationCall, parent) + + var throwExpression: (throwExpression: FirThrowExpression, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformThrowExpression(throwExpression: FirThrowExpression, parent: FirElement): FirStatement = + throwExpression(throwExpression, parent) + + var variableAssignment: (variableAssignment: FirVariableAssignment, parent: FirElement) -> FirStatement = { el, _ -> el } + override fun transformVariableAssignment(variableAssignment: FirVariableAssignment, parent: FirElement): FirStatement = + variableAssignment(variableAssignment, parent) + + var whenSubjectExpression: (whenSubjectExpression: FirWhenSubjectExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformWhenSubjectExpression( + whenSubjectExpression: FirWhenSubjectExpression, + parent: FirElement + ): FirStatement = + whenSubjectExpression(whenSubjectExpression, parent) + + var wrappedDelegateExpression: (wrappedDelegateExpression: FirWrappedDelegateExpression, parent: FirElement) -> FirStatement = + { el, _ -> el } + + override fun transformWrappedDelegateExpression( + wrappedDelegateExpression: FirWrappedDelegateExpression, + parent: FirElement + ): FirStatement = + wrappedDelegateExpression(wrappedDelegateExpression, parent) + + var namedReference: (namedReference: FirNamedReference, parent: FirElement) -> FirReference = { el, _ -> el } + override fun transformNamedReference(namedReference: FirNamedReference, parent: FirElement): FirReference = + namedReference(namedReference, parent) + + var namedReferenceWithCandidateBase: (namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, parent: FirElement) -> FirReference = + { el, _ -> el } + + override fun transformNamedReferenceWithCandidateBase( + namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, + parent: FirElement + ): FirReference = + namedReferenceWithCandidateBase(namedReferenceWithCandidateBase, parent) + + var errorNamedReference: (errorNamedReference: FirErrorNamedReference, parent: FirElement) -> FirReference = { el, _ -> el } + override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, parent: FirElement): FirReference = + errorNamedReference(errorNamedReference, parent) + + var superReference: (superReference: FirSuperReference, parent: FirElement) -> FirReference = { el, _ -> el } + override fun transformSuperReference(superReference: FirSuperReference, parent: FirElement): FirReference = + superReference(superReference, parent) + + var thisReference: (thisReference: FirThisReference, parent: FirElement) -> FirReference = { el, _ -> el } + override fun transformThisReference(thisReference: FirThisReference, parent: FirElement): FirReference = + thisReference(thisReference, parent) + + var controlFlowGraphReference: (controlFlowGraphReference: FirControlFlowGraphReference, parent: FirElement) -> FirReference = + { el, _ -> el } + + override fun transformControlFlowGraphReference( + controlFlowGraphReference: FirControlFlowGraphReference, + parent: FirElement + ): FirReference = + controlFlowGraphReference(controlFlowGraphReference, parent) + + var resolvedNamedReference: (resolvedNamedReference: FirResolvedNamedReference, parent: FirElement) -> FirReference = + { el, _ -> el } + + override fun transformResolvedNamedReference( + resolvedNamedReference: FirResolvedNamedReference, + parent: FirElement + ): FirReference = + resolvedNamedReference(resolvedNamedReference, parent) + + var resolvedErrorReference: (resolvedErrorReference: FirResolvedErrorReference, parent: FirElement) -> FirReference = + { el, _ -> el } + + override fun transformResolvedErrorReference( + resolvedErrorReference: FirResolvedErrorReference, + parent: FirElement + ): FirReference = + resolvedErrorReference(resolvedErrorReference, parent) + + var delegateFieldReference: (delegateFieldReference: FirDelegateFieldReference, parent: FirElement) -> FirReference = + { el, _ -> el } + + override fun transformDelegateFieldReference( + delegateFieldReference: FirDelegateFieldReference, + parent: FirElement + ): FirReference = + delegateFieldReference(delegateFieldReference, parent) + + var backingFieldReference: (backingFieldReference: FirBackingFieldReference, parent: FirElement) -> FirReference = + { el, _ -> el } + + override fun transformBackingFieldReference( + backingFieldReference: FirBackingFieldReference, + parent: FirElement + ): FirReference = + backingFieldReference(backingFieldReference, parent) + + var resolvedCallableReference: (resolvedCallableReference: FirResolvedCallableReference, parent: FirElement) -> FirReference = + { el, _ -> el } + + override fun transformResolvedCallableReference( + resolvedCallableReference: FirResolvedCallableReference, + parent: FirElement + ): FirReference = + resolvedCallableReference(resolvedCallableReference, parent) + + var resolvedTypeRef: (resolvedTypeRef: FirResolvedTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } + override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, parent: FirElement): FirTypeRef = + resolvedTypeRef(resolvedTypeRef, parent) + + var errorTypeRef: (errorTypeRef: FirErrorTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } + override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, parent: FirElement): FirTypeRef = + errorTypeRef(errorTypeRef, parent) + + var typeRefWithNullability: (typeRefWithNullability: FirTypeRefWithNullability, parent: FirElement) -> FirTypeRef = + { el, _ -> el } + + override fun transformTypeRefWithNullability( + typeRefWithNullability: FirTypeRefWithNullability, + parent: FirElement + ): FirTypeRef = + typeRefWithNullability(typeRefWithNullability, parent) + + var userTypeRef: (userTypeRef: FirUserTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } + override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, parent: FirElement): FirTypeRef = + userTypeRef(userTypeRef, parent) + + var dynamicTypeRef: (dynamicTypeRef: FirDynamicTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } + override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, parent: FirElement): FirTypeRef = + dynamicTypeRef(dynamicTypeRef, parent) + + var functionTypeRef: (functionTypeRef: FirFunctionTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } + override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, parent: FirElement): FirTypeRef = + functionTypeRef(functionTypeRef, parent) + + var intersectionTypeRef: (intersectionTypeRef: FirIntersectionTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } + override fun transformIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, parent: FirElement): FirTypeRef = + intersectionTypeRef(intersectionTypeRef, parent) + + var implicitTypeRef: (implicitTypeRef: FirImplicitTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } + override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, parent: FirElement): FirTypeRef = + implicitTypeRef(implicitTypeRef, parent) + + var effectDeclaration: (effectDeclaration: FirEffectDeclaration, parent: FirElement) -> FirEffectDeclaration = { el, _ -> el } + override fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, parent: FirElement): FirEffectDeclaration = + effectDeclaration(effectDeclaration, parent) + + var contractDescription: (contractDescription: FirContractDescription, parent: FirElement) -> FirContractDescription = + { el, _ -> el } + + override fun transformContractDescription( + contractDescription: FirContractDescription, + parent: FirElement + ): FirContractDescription = + contractDescription(contractDescription, parent) + + var legacyRawContractDescription: (legacyRawContractDescription: FirLegacyRawContractDescription, parent: FirElement) -> FirContractDescription = + { el, _ -> el } + + override fun transformLegacyRawContractDescription( + legacyRawContractDescription: FirLegacyRawContractDescription, + parent: FirElement + ): FirContractDescription = + legacyRawContractDescription(legacyRawContractDescription, parent) + + var rawContractDescription: (rawContractDescription: FirRawContractDescription, parent: FirElement) -> FirContractDescription = + { el, _ -> el } + + override fun transformRawContractDescription( + rawContractDescription: FirRawContractDescription, + parent: FirElement + ): FirContractDescription = + rawContractDescription(rawContractDescription, parent) + + var resolvedContractDescription: (resolvedContractDescription: FirResolvedContractDescription, parent: FirElement) -> FirContractDescription = + { el, _ -> el } + + override fun transformResolvedContractDescription( + resolvedContractDescription: FirResolvedContractDescription, + parent: FirElement + ): FirContractDescription = + resolvedContractDescription(resolvedContractDescription, parent) + + } + + companion object { + operator fun invoke(init: Builder.() -> Unit): (FirSession) -> Transformer = + { Builder(it).apply(init) } + } + +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/TypeAttributes.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/TypeAttributes.kt new file mode 100644 index 0000000..702b460 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/TypeAttributes.kt @@ -0,0 +1,24 @@ +package arrow.meta.plugins + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirAnnotation +import org.jetbrains.kotlin.fir.types.ConeAttribute + +interface TypeAttributes : FrontendPlugin { + fun convertAttributeToAnnotation(attribute: ConeAttribute<*>): FirAnnotation? + fun extractAttributeFromAnnotation(annotation: FirAnnotation): ConeAttribute<*>? + class Builder(override val session: FirSession) : TypeAttributes, FrontendPlugin.Builder() { + var attributeToAnnotation: (ConeAttribute<*>) -> FirAnnotation? = { null } + var attributeFromAnnotation: (FirAnnotation) -> ConeAttribute<*>? = { null } + override fun convertAttributeToAnnotation(attribute: ConeAttribute<*>): FirAnnotation? = + attributeToAnnotation(attribute) + + override fun extractAttributeFromAnnotation(annotation: FirAnnotation): ConeAttribute<*>? = + attributeFromAnnotation(annotation) + } + + companion object { + operator fun invoke(init: Builder.() -> Unit): (FirSession) -> TypeAttributes = + { Builder(it).apply(init) } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/example/ExampleFull.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/example/ExampleFull.kt new file mode 100644 index 0000000..4e4f9c4 --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/example/ExampleFull.kt @@ -0,0 +1,77 @@ +package arrow.meta.plugins.example + +import arrow.meta.Meta +import arrow.meta.plugins.* + + +/** + * A global compiler plugin that mirrors the extensions + * in the Kotlin compiler + */ +@Meta +class MyCompilerPluginWithDSL : FrontendPlugin.Builder() { + init { + +Supertypes { + shouldTransformSupertypes = { false } + additionalSupertypes = { _, _ -> emptyList() } + } + +ScriptConfigurator { + configureScript = { fileBuilder -> } + } + +SAMConversionTransformer { + getCustomFunctionalTypeForSamConversion = { function -> null } + } + +ExpressionResolution { + newImplicitReceivers = { emptyList() } + } + +Checkers { + expressionCheckers.add { expression, context, reporter -> } + declarationCheckers.add { declaration, context, reporter -> } + typeCheckers.add { type, context, reporter -> } + } + +Generation { + callableNamesForClass = { emptySet() } + nestedClassifiersNames = { emptySet() } + topLevelCallableIds = { emptySet() } + topLevelClassIds = { emptySet() } + containsPackage = { false } + classLikeDeclaration = { null } + constructors = { emptyList() } + functions = { _, _ -> emptyList() } + properties = { _, _ -> emptyList() } + } + +Transformer { + file = { file, _ -> file } + declaration = { declaration, _ -> declaration } + expression = { expression, _ -> expression } + statement = { statement, _ -> statement } + typeAlias = { typeAlias, _ -> typeAlias } + typeParameter = { typeParameter, _ -> typeParameter } + valueParameter = { valueParameter, _ -> valueParameter } + property = { property, _ -> property } + function = { function, _ -> function } + classLikeDeclaration = { classLikeDeclaration, _ -> classLikeDeclaration } + typeRef = { typeRef, _ -> typeRef } + annotation = { annotation, _ -> annotation } + call = { call, _ -> call } + import = { import, _ -> import } + loop = { loop, _ -> loop } + jump = { jump, _ -> jump } + whenExpression = { whenExpression, _ -> whenExpression } + tryExpression = { tryExpression, _ -> tryExpression } + catch = { catch, _ -> catch } + block = { block, _ -> block } + qualifiedAccess = { qualifiedAccess, _ -> qualifiedAccess } + variableAssignment = { variableAssignment, _ -> variableAssignment } + binaryLogicExpression = { binaryLogicExpression, _ -> binaryLogicExpression } + backingField = { backingField, _ -> backingField } + backingFieldReference = { backingFieldReference, _ -> backingFieldReference } + delegatedConstructorCall = { delegatedConstructorCall, _ -> delegatedConstructorCall } + enumEntry = { enumEntry, _ -> enumEntry } + errorExpression = { errorExpression, _ -> errorExpression } + resolvedQualifier = { resolvedQualifier, _ -> resolvedQualifier } + contextReceiver = { contextReceiver, _ -> contextReceiver } + elvisExpression = { elvisExpression, _ -> elvisExpression } + } + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Product.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Product.kt index c95a3ab..0c2f3e3 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Product.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Product.kt @@ -1,6 +1,6 @@ package arrow.meta.samples -import arrow.meta.FirMetaContext +import arrow.meta.FirMetaMemberGenerationContext import arrow.meta.Meta import org.jetbrains.kotlin.fir.declarations.* @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.* annotation class Product { companion object : Meta.Generate.Members.Functions { - override fun FirMetaContext.newFunctions(firClass: FirClass): Map String> = + override fun FirMetaMemberGenerationContext.newFunctions(firClass: FirClass): Map String> = mapOf( "product" to { //language=kotlin diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt new file mode 100644 index 0000000..34b450b --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt @@ -0,0 +1,412 @@ +package arrow.meta.samples + +import arrow.meta.FirMetaCheckerContext +import arrow.meta.FirMetaContext +import arrow.meta.Meta +import org.jetbrains.kotlin.KtSourceElement +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.FirAnnotationContainer +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.utils.* +import org.jetbrains.kotlin.fir.expressions.FirGetClassCall +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.extensions.predicate.LookupPredicate +import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider +import org.jetbrains.kotlin.fir.resolve.defaultType +import org.jetbrains.kotlin.fir.resolve.fqName +import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol +import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.visitors.FirTransformer +import org.jetbrains.kotlin.fir.visitors.FirVisitor +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.Variance +import kotlin.reflect.* + + +@Target(AnnotationTarget.EXPRESSION, AnnotationTarget.CLASS) +@Retention(AnnotationRetention.SOURCE) +@Meta +annotation class Reflect { + companion object : + //Meta.FrontendTransformer.RegularClass, + Meta.FrontendTransformer.GetClassCall, + Meta.Generate.TopLevel.Class { + + override fun FirMetaContext.classes(): Set { + val reflected = session.predicateBasedProvider.getSymbolsByPredicate(LookupPredicate.create { annotatedOrUnder(FqName(Reflect::class.java.canonicalName)) }) + return reflected.filterIsInstance>().map { ClassId.fromString(it.classId.asFqNameString().replace(".", "/") + Reflect::class.java.simpleName) }.toSet() + } + + @OptIn(SymbolInternals::class) + override fun FirMetaContext.classes(classId: ClassId): FirClass { + val targetClassId = ClassId.fromString(classId.asSingleFqName().asString().removeSuffix(Reflect::class.java.simpleName)) + val target = session.symbolProvider.getClassLikeSymbolByClassId(targetClassId)?.fir as? FirRegularClass + + return target?.let { compile(kClass(it)) } ?: error("Could not find class $targetClassId") + } + +// override fun FirMetaMemberGenerationContext.nestedClasses(firClass: FirClassSymbol<*>): Set { +// val isReflected = +// firClass.annotations.any { it.annotationTypeRef.source?.text == Reflect::class.java.simpleName } +// return if (isReflected) { +// setOf(Name.identifier("Reflected")) +// } else emptySet() +// } + +// @OptIn(SymbolInternals::class) +// override fun FirMetaMemberGenerationContext.nestedClasses(classId: ClassId): List = +// classId.parentClassId?.let { parentId -> +// val parent = session.symbolProvider.getClassLikeSymbolByClassId(parentId)?.fir as? FirRegularClass +// parent?.declarations?.filterIsInstance()?.filter { classId == it.classId } ?: emptyList() +// } ?: emptyList() + + override fun FirMetaCheckerContext.getClassCall(getClassCall: FirGetClassCall): FirStatement { + return "${+getClassCall.argument.typeRef}${Reflect::class.java.simpleName}()".call + } + +// override fun FirMetaCheckerContext.regularClass(regularClass: FirRegularClass): FirStatement { +// val kClassSource = kClass(regularClass) +// return regularClass.addDeclarations(compile(kClassSource)) +// } + } +} + +interface CompileTimeReflected : KClass + +@OptIn(SymbolInternals::class) +fun FirMetaContext.kClass(firClass: FirRegularClass): String { + val supertypes = firClass.superTypeRefs + val constructors = firClass.indexedDeclarations() + val properties = firClass.indexedDeclarations() + val functions = firClass.indexedDeclarations() + val nestedClasses = firClass.indexedDeclarations() + val sealedSubclasses = when { + firClass.isSealed -> firClass + .getSealedClassInheritors(session) + .mapNotNull { session.symbolProvider.getClassLikeSymbolByClassId(it)?.fir } + .filterIsInstance() + + else -> emptyList() + } + //language=kotlin + return """ + import kotlin.reflect.* + + class Reflected : arrow.meta.samples.CompileTimeReflected<${firClass.classId.asFqNameString()}> { + + // constructors + ${constructors.joinToString("\n") { (n, it) -> kFunction(n, it) }} + + // properties + ${properties.joinToString("\n") { (_, it) -> kProperty(firClass, it) }} + + //functions + ${functions.joinToString("\n") { (n, it) -> kFunction(n, it) }} + + //nested classes + ${nestedClasses.joinToString("\n") { (_, it) -> kClass(it) }} + + //sealed subclases + ${sealedSubclasses.joinToString("\n") { kClass(it) }} + + + override val annotations: List by lazy { ${reflectedAnnotations(firClass)} } + + override val constructors: Collection> by lazy { + listOf(${constructors.joinToString { (n, it) -> "${kFunctionName(n, it)}()" }}) + } + + override val members: Collection> by lazy { + listOf(${properties.joinToString { (_, it) -> "${+it.name}()" }}) + + listOf(${functions.joinToString { (n, it) -> "${kFunctionName(n, it)}()" }}) + } + + + override val nestedClasses: Collection> by lazy { + listOf(${nestedClasses.joinToString { (_, it) -> "${+it.name}()" }}) + } + + override val sealedSubclasses: List> by lazy { + listOf(${sealedSubclasses.joinToString { "${+it.name}()" }}) + } + + + override val supertypes: List by lazy { + listOf(${supertypes.joinToString { kType(it) }}) + } + + + override val isAbstract: Boolean by lazy { ${firClass.isAbstract} } + override val isCompanion: Boolean by lazy { ${firClass.isCompanion} } + override val isData: Boolean by lazy { ${firClass.isData} } + override val isFinal: Boolean by lazy { ${firClass.isFinal} } + override val isFun: Boolean by lazy { ${firClass.isFun} } + override val isInner: Boolean by lazy { ${firClass.isInner} } + override val isOpen: Boolean by lazy { ${firClass.isOpen} } + override val isSealed: Boolean by lazy { ${firClass.isSealed} } + override val isValue: Boolean by lazy { ${firClass.isInline} } + override val objectInstance: ${firClass.classId.asFqNameString()}? by lazy { + ${if (firClass.classKind == ClassKind.OBJECT) firClass.classId.asFqNameString() else null} + } + override val qualifiedName: String by lazy { "${firClass.classId.asFqNameString()}" } + override val simpleName: String by lazy { "${firClass.classId.shortClassName}" } + override val typeParameters: List by lazy { + listOf(${firClass.typeParameters.joinToString { kTypeParameter(it.symbol.fir) }}) + } + override val visibility: KVisibility? by lazy { ${kVisibility(firClass.visibility)} } + + override fun equals(other: Any?): Boolean = + TODO() //${firClass.classId.asFqNameString()}::class.equals(other) + + override fun hashCode(): Int = + TODO() //${firClass.classId.asFqNameString()}::class.hashCode() + + override fun isInstance(value: Any?): Boolean = + value is ${firClass.classId.asFqNameString()} + } + """ +} + +private inline fun FirRegularClass.indexedDeclarations(): List> = + declarations.filterIsInstance().filter { !it.isSynthetic }.mapIndexed { index, t -> index to t } + + +private fun FirMetaContext.reflectedAnnotations(container: FirAnnotationContainer): String = + """listOf(${ + container.annotations.mapNotNull { ann -> ann.fqName(session)?.let { ann to it.asString() } } + .joinToString { (ann, fqName) -> "$fqName(${ann.argumentMapping.mapping.entries.joinToString { (k, v) -> "${+k} = ${+v}" }})" } + })""" + +@OptIn(SymbolInternals::class) +private fun FirMetaContext.kFunction(n: Int, fn: FirFunction): String = + source( + """ +inner class ${kFunctionName(n, fn)} : KFunction<${+fn.returnTypeRef}> { + override val annotations: List by lazy { ${reflectedAnnotations(fn)} } + override val isAbstract: Boolean by lazy { ${fn.isAbstract} } + override val isFinal: Boolean by lazy { ${fn.isFinal} } + override val isOpen: Boolean by lazy { ${fn.isOpen} } + override val name: String by lazy { "${name(fn)}" } + override val parameters: List by lazy { + listOf(${fn.valueParameters.mapIndexed { i, p -> kParameter(i, p) }.joinToString()}) + } + override val returnType: KType by lazy { ${kType(fn.returnTypeRef)} } + override val typeParameters: List by lazy { + listOf(${fn.typeParameters.joinToString { kTypeParameter(it.symbol.fir) }}) + } + override val visibility: KVisibility? by lazy { ${kVisibility(fn.visibility)} } + + override fun call(vararg args: Any?): ${+fn.returnTypeRef} { + TODO("Not yet implemented") + } + + override fun callBy(args: Map): ${+fn.returnTypeRef} { + TODO("Not yet implemented") + } + + override val isExternal: Boolean by lazy { ${fn.isExternal} } + override val isInfix: Boolean by lazy { ${fn.isInfix} } + override val isInline: Boolean by lazy { ${fn.isInline} } + override val isOperator: Boolean by lazy { ${fn.isOperator} } + override val isSuspend: Boolean by lazy { ${fn.isSuspend} } +} +""" + ) + +private fun FirMetaContext.kFunctionName(n: Int, fn: FirFunction): String = + when (fn) { + is FirSimpleFunction -> +fn.name + is FirConstructor -> "constructor$n" + else -> error("expected FirSimpleFunction or FirConstructor") + } + +private fun name(member: FirMemberDeclaration): String = + when (member) { + is FirSimpleFunction -> member.name.asString() + is FirConstructor -> Name.special("").asString() + else -> Name.special("").asString() + } + +@OptIn(SymbolInternals::class) +private fun FirMetaContext.kType(type: FirTypeRef): String = + source( + """ + object : KType { + override val annotations: List by lazy { ${reflectedAnnotations(type)} } + override val arguments: List by lazy { + listOf(${type.extractTypeArguments().joinToString { kTypeProjection(it) }}) + } + override val classifier: KClassifier? by lazy { + null //${ + type.coneType.toRegularClassSymbol(session)?.fir?.classId?.asFqNameString()?.let { "$it::class" } ?: "null" + } + } + override val isMarkedNullable: Boolean by lazy { ${type.isMarkedNullable} } + } +""" + ) + +internal class ReflectTypeProjectionWithVariance( + override val source: KtSourceElement?, + override var typeRef: FirTypeRef, + override val variance: Variance, +) : FirTypeProjectionWithVariance() { + override fun acceptChildren(visitor: FirVisitor, data: D) { + typeRef.accept(visitor, data) + } + + override fun transformChildren(transformer: FirTransformer, data: D): ReflectTypeProjectionWithVariance { + typeRef = typeRef.transform(transformer, data) + return this + } +} + +fun ProjectionKind.toVariance(): Variance = + when (this) { + ProjectionKind.STAR -> Variance.INVARIANT + ProjectionKind.IN -> Variance.IN_VARIANCE + ProjectionKind.OUT -> Variance.OUT_VARIANCE + ProjectionKind.INVARIANT -> Variance.INVARIANT + } + +fun FirTypeRef.extractTypeArguments(): List { + return when (this) { + is FirResolvedTypeRef -> type.typeArguments.mapNotNull { + val resolved = it.type?.toFirResolvedTypeRef() + if (resolved != null) ReflectTypeProjectionWithVariance(null, resolved, it.kind.toVariance()) + else null + } + + is FirUserTypeRef -> qualifier.flatMap { it.typeArgumentList.typeArguments.map { it } } + else -> emptyList() + } +} + +private fun FirMetaContext.kProperty(owner: FirRegularClass, prop: FirProperty): String = + source( + """ + inner class ${+prop.name} : KProperty1<${owner.renderType()}, ${+prop.returnTypeRef}> { + override val annotations: List by lazy { + listOf() + } + override val isAbstract: Boolean by lazy { ${prop.isAbstract} } + override val isFinal: Boolean by lazy { ${prop.isFinal} } + override val isOpen: Boolean by lazy { ${prop.isOpen} } + override val isSuspend: Boolean by lazy { ${prop.isSuspend} } + override val name: String by lazy { "${+prop.name}" } + override val parameters: List by lazy { ${kParameters(prop)} } + override val returnType: KType by lazy { ${kType(prop.returnTypeRef)} } + override val typeParameters: List by lazy { listOf(${ + prop.typeParameters.joinToString { + kTypeParameter( + it + ) + } + }) } + override val visibility: KVisibility? by lazy { ${kVisibility(prop.visibility)} } + + override fun call(vararg args: Any?): ${+prop.returnTypeRef} { + TODO("Not yet implemented") + } + + override fun callBy(args: Map): ${+prop.returnTypeRef} { + TODO("Not yet implemented") + } + + override val isConst: Boolean by lazy { ${prop.isConst} } + override val isLateinit: Boolean by lazy { ${prop.isLateInit} } + override val getter: KProperty1.Getter<${owner.renderType()}, ${+prop.returnTypeRef}> by lazy { + TODO() + } + + override fun get(receiver: ${owner.renderType()}): ${+prop.returnTypeRef} { + TODO("Not yet implemented") + } + + override fun getDelegate(receiver: ${owner.renderType()}): Any? { + TODO("Not yet implemented") + } + + override fun invoke(p1: ${owner.renderType()}): ${+prop.returnTypeRef} { + TODO("Not yet implemented") + } + + } +""" + ) + +private fun FirRegularClass.renderType(): String = + defaultType().type.renderReadableWithFqNames().replace("/", ".") + + +private fun FirMetaContext.kTypeParameter(type: FirTypeParameter): String = + source( + """ +object : KTypeParameter { + override val annotations: List by lazy { ${reflectedAnnotations(type)} } + override val isReified: Boolean by lazy { ${type.isReified} } + override val name: String by lazy { "${type.name}" } + override val upperBounds: List by lazy { + listOf(${type.bounds.joinToString { kType(it) }}) + } + override val variance: KVariance by lazy { ${kVariance(type.variance)} } +} +""" + ) + +private fun kVariance(variance: Variance): String = + when (variance) { + Variance.INVARIANT -> "Variance.INVARIANT" + Variance.IN_VARIANCE -> "KVariance.IN" + Variance.OUT_VARIANCE -> "KVariance.OUT" + } + +private fun kVisibility(visibility: Visibility): String = + when (visibility) { + Visibilities.Public -> "KVisibility.PUBLIC" + Visibilities.Protected -> "KVisibility.PROTECTED" + Visibilities.Internal -> "KVisibility.INTERNAL" + Visibilities.Private -> "KVisibility.PRIVATE" + else -> "" + + "KVisibility.PUBLIC" + } + +private fun FirMetaContext.kParameters(fn: FirMemberDeclaration): String = + if (fn is FirFunction) + """listOf(${fn.valueParameters.mapIndexed { n, p -> kParameter(n, p) }.joinToString()})""" + else "emptyList()" + +private fun FirMetaContext.kParameter(n: Int, param: FirValueParameter): String = + source( + """ + object : KParameter { + override val annotations: List by lazy { ${reflectedAnnotations(param)} } + override val index: Int by lazy { $n } + override val isOptional: Boolean by lazy { ${param.defaultValue != null} } + override val isVararg: Boolean by lazy { ${param.isVararg} } + override val kind: KParameter.Kind by lazy { TODO() } + override val name: String? by lazy { "${param.name}" } + override val type: KType by lazy { ${kType(param.returnTypeRef)} } + } +""" + ) + +private fun FirMetaContext.kTypeProjection(projection: FirTypeProjection): String = + when (projection) { + is FirStarProjection -> "KTypeProjection.STAR" + is FirTypeProjectionWithVariance -> source( + """ + KTypeProjection(${kVariance(projection.variance)}, ${kType(projection.typeRef)}) + """ + ) + + else -> error("expected FirStarProjection or FirTypeProjectionWithVariance") + } + + diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/FirArrowReflectExtensionRegistrar.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/FirArrowReflectExtensionRegistrar.kt index f71420d..c72fb67 100644 --- a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/FirArrowReflectExtensionRegistrar.kt +++ b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/FirArrowReflectExtensionRegistrar.kt @@ -1,16 +1,76 @@ package arrow.reflect.compiler.plugin.fir import arrow.meta.TemplateCompiler +import arrow.meta.plugins.* import arrow.reflect.compiler.plugin.fir.checkers.FirMetaAdditionalCheckersExtension +import arrow.reflect.compiler.plugin.fir.codegen.CompilerPluginGenerationExtension import arrow.reflect.compiler.plugin.fir.codegen.FirMetaCodegenExtension import arrow.reflect.compiler.plugin.targets.MetaTarget +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirFileChecker +import org.jetbrains.kotlin.fir.analysis.checkers.expression.ExpressionCheckers +import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirBasicExpressionChecker +import org.jetbrains.kotlin.fir.analysis.checkers.type.FirTypeRefChecker +import org.jetbrains.kotlin.fir.analysis.checkers.type.TypeCheckers +import org.jetbrains.kotlin.fir.analysis.extensions.FirAdditionalCheckersExtension +import org.jetbrains.kotlin.fir.builder.FirScriptConfiguratorExtension +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.builder.FirFileBuilder +import org.jetbrains.kotlin.fir.declarations.builder.FirScriptBuilder +import org.jetbrains.kotlin.fir.expressions.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment +import org.jetbrains.kotlin.fir.extensions.* +import org.jetbrains.kotlin.fir.resolve.FirSamConversionTransformerExtension +import org.jetbrains.kotlin.fir.types.* +import kotlin.reflect.full.isSubclassOf class FirArrowReflectExtensionRegistrar(val templateCompiler: TemplateCompiler, val metaTargets: List) : FirExtensionRegistrar() { + private fun compilerPlugins(): Sequence<(FirSession) -> FrontendPlugin> = + metaTargets.filter { it.companion.isSubclassOf(FrontendPlugin.Builder::class) } + .map { it.companion.objectInstance } + .distinct() + .filterIsInstance() + .asSequence() + .flatMap { + it.plugins + } + override fun ExtensionRegistrarContext.configurePlugin() { + val compilerPlugins = compilerPlugins() + compilerPlugins.forEach { pluginFn -> + val registration = { session: FirSession -> + val plugin = pluginFn(session) + val result = when (plugin) { + is Supertypes -> registerSuperTypes(plugin) + is StatusTransformer -> registerStatusTransformer(plugin) + is AssignmentTransformer -> registerAssignmentTransformer(plugin) + is Checkers -> registerCheckers(plugin) + is ExpressionResolution -> registerExpressionResolution(plugin) + is Generation -> registerGeneration(plugin) + is SAMConversionTransformer -> registerSAMConversionTransformer(plugin) + is ScriptConfigurator -> registerScriptConfigurator(plugin) + is Transformer -> registerTransformer(plugin) + is TypeAttributes -> registerTypeAttributes(plugin) + } + result + } + + +{ session: FirSession -> + templateCompiler.session = session + FirMetaCodegenExtension(session, templateCompiler, metaTargets) + } + } + + //todo remove old stuff below when compiler plugin is ready +{ session: FirSession -> templateCompiler.session = session FirMetaCodegenExtension(session, templateCompiler, metaTargets) @@ -20,4 +80,130 @@ class FirArrowReflectExtensionRegistrar(val templateCompiler: TemplateCompiler, FirMetaAdditionalCheckersExtension(session, templateCompiler, metaTargets) } } + + private fun ExtensionRegistrarContext.registerTransformer(plugin: Transformer) = + object : FirAdditionalCheckersExtension(plugin.session) { + override val declarationCheckers: DeclarationCheckers + get() = object : DeclarationCheckers() { + override val fileCheckers: Set + get() = setOf(object : FirFileChecker() { + override fun check(declaration: FirFile, context: CheckerContext, reporter: DiagnosticReporter) { + declaration.transform(MetaFirTransformer(plugin), declaration) + } + }) + } + } + + + private fun registerTypeAttributes(plugin: TypeAttributes): FirTypeAttributeExtension = + object : FirTypeAttributeExtension(plugin.session) { + override fun convertAttributeToAnnotation(attribute: ConeAttribute<*>): FirAnnotation? { + return plugin.convertAttributeToAnnotation(attribute) + } + + override fun extractAttributeFromAnnotation(annotation: FirAnnotation): ConeAttribute<*>? { + return plugin.extractAttributeFromAnnotation(annotation) + } + } + + + private fun registerScriptConfigurator(plugin: ScriptConfigurator) = + object : FirScriptConfiguratorExtension(plugin.session) { + override fun FirScriptBuilder.configure(fileBuilder: FirFileBuilder) { + plugin.run { configure(fileBuilder) } + } + } + + + private fun registerSAMConversionTransformer(plugin: SAMConversionTransformer) = + object : FirSamConversionTransformerExtension(plugin.session) { + override fun getCustomFunctionalTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? { + return plugin.getCustomFunctionalTypeForSamConversion(function) + } + } + + + private fun registerGeneration(plugin: Generation) = + CompilerPluginGenerationExtension(plugin.session, plugin) + + private fun registerExpressionResolution(plugin: ExpressionResolution) = + object : FirExpressionResolutionExtension(plugin.session) { + override fun addNewImplicitReceivers(functionCall: FirFunctionCall): List { + return plugin.addNewImplicitReceivers(functionCall) + } + } + + + private fun registerCheckers(plugin: Checkers) = + object : FirAdditionalCheckersExtension(plugin.session) { + override val declarationCheckers: DeclarationCheckers + get() = object : DeclarationCheckers() { + override val basicDeclarationCheckers: Set + get() = plugin.declarationCheckers.map { + object : FirBasicDeclarationChecker() { + override fun check( + declaration: FirDeclaration, + context: CheckerContext, + reporter: DiagnosticReporter + ) { + it.check(declaration, context, reporter) + } + } + }.toSet() + } + override val expressionCheckers: ExpressionCheckers + get() = object : ExpressionCheckers() { + override val basicExpressionCheckers: Set + get() = plugin.expressionCheckers.map { + object : FirBasicExpressionChecker() { + override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) { + it.check(expression, context, reporter) + } + } + }.toSet() + } + override val typeCheckers: TypeCheckers + get() = object : TypeCheckers() { + override val typeRefCheckers: Set + get() = plugin.typeCheckers.map { + object : FirTypeRefChecker() { + override fun check(typeRef: FirTypeRef, context: CheckerContext, reporter: DiagnosticReporter) { + it.check(typeRef, context, reporter) + } + } + }.toSet() + } + } + + + private fun registerAssignmentTransformer(plugin: AssignmentTransformer) = + object : FirAssignExpressionAltererExtension(plugin.session) { + override fun transformVariableAssignment(variableAssignment: FirVariableAssignment): FirStatement? { + return plugin.transformVariableAssignment(variableAssignment) + } + } + + private fun registerSuperTypes(plugin: Supertypes): FirSupertypeGenerationExtension = + object : FirSupertypeGenerationExtension(plugin.session) { + context(TypeResolveServiceContainer) override fun computeAdditionalSupertypes( + classLikeDeclaration: FirClassLikeDeclaration, + resolvedSupertypes: List + ): List = + plugin.computeAdditionalSupertypes(classLikeDeclaration, resolvedSupertypes) + + override fun needTransformSupertypes(declaration: FirClassLikeDeclaration): Boolean = + plugin.needTransformSupertypes(declaration) + } + + private fun registerStatusTransformer(plugin: StatusTransformer) = + object : FirStatusTransformerExtension(plugin.session) { + override fun needTransformStatus(declaration: FirDeclaration): Boolean = + plugin.needTransformStatus(declaration) + + override fun transformStatus(status: FirDeclarationStatus, declaration: FirDeclaration): FirDeclarationStatus = + plugin.transformStatus(status, declaration) + } + + } + diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/checkers/FirMetaAdditionalCheckersExtension.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/checkers/FirMetaAdditionalCheckersExtension.kt index 26e6045..d0824ec 100644 --- a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/checkers/FirMetaAdditionalCheckersExtension.kt +++ b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/checkers/FirMetaAdditionalCheckersExtension.kt @@ -40,7 +40,7 @@ class FirMetaAdditionalCheckersExtension( invokeChecker(Meta.Checker.Declaration::class, declaration, session, context, reporter) if (!templateCompiler.compiling && declaration is FirFile) { val transformer = FirMetaTransformer(session, templateCompiler, metaTargets, context, reporter) - transformer.transformDeclaration(declaration, Unit) + transformer.transformDeclaration(declaration, declaration) } } } @@ -68,6 +68,7 @@ class FirMetaAdditionalCheckersExtension( val annotations = element.metaAnnotations(session) val metaContext = FirMetaCheckerContext(templateCompiler, session, context, reporter) invokeMeta( + false, metaContext, annotations, superType = superType, diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/CompilerPluginGenerationExtension.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/CompilerPluginGenerationExtension.kt new file mode 100644 index 0000000..1331d6d --- /dev/null +++ b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/CompilerPluginGenerationExtension.kt @@ -0,0 +1,58 @@ +package arrow.reflect.compiler.plugin.fir.codegen + +import arrow.meta.plugins.Generation +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension +import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar +import org.jetbrains.kotlin.fir.extensions.MemberGenerationContext +import org.jetbrains.kotlin.fir.symbols.impl.* +import org.jetbrains.kotlin.name.CallableId +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name + +class CompilerPluginGenerationExtension(session: FirSession, val compilerPlugin: Generation) : + FirDeclarationGenerationExtension(session) { + override fun generateClassLikeDeclaration(classId: ClassId): FirClassLikeSymbol<*>? { + return compilerPlugin.generateClassLikeDeclaration(classId) + } + + override fun generateConstructors(context: MemberGenerationContext): List { + return compilerPlugin.generateConstructors(context) + } + + override fun generateFunctions( + callableId: CallableId, + context: MemberGenerationContext? + ): List { + return compilerPlugin.generateFunctions(callableId, context) + } + + override fun generateProperties(callableId: CallableId, context: MemberGenerationContext?): List { + return compilerPlugin.generateProperties(callableId, context) + } + + override fun getCallableNamesForClass(classSymbol: FirClassSymbol<*>): Set { + return compilerPlugin.getCallableNamesForClass(classSymbol) + } + + override fun getNestedClassifiersNames(classSymbol: FirClassSymbol<*>): Set { + return compilerPlugin.getNestedClassifiersNames(classSymbol) + } + + override fun getTopLevelCallableIds(): Set { + return compilerPlugin.getTopLevelCallableIds() + } + + override fun getTopLevelClassIds(): Set { + return compilerPlugin.getTopLevelClassIds() + } + + override fun hasPackage(packageFqName: FqName): Boolean { + return compilerPlugin.hasPackage(packageFqName) + } + + override fun FirDeclarationPredicateRegistrar.registerPredicates() { + register(compilerPlugin.metaAnnotatedPredicate) + } +} diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/FirMetaCodegenExtension.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/FirMetaCodegenExtension.kt index 975389f..5a10b47 100644 --- a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/FirMetaCodegenExtension.kt +++ b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/FirMetaCodegenExtension.kt @@ -38,22 +38,36 @@ class FirMetaCodegenExtension( FirMetaMemberGenerationContext(templateCompiler, session, generationContext) override fun generateClassLikeDeclaration(classId: ClassId): FirClassLikeSymbol<*>? { - val annotations = - session.symbolProvider - .getClassLikeSymbolByClassId(classId) - ?.fir - ?.metaAnnotations(session) - .orEmpty() - val firClass: FirClass? = - invokeMeta(metaContext(null), annotations, Meta.Generate.TopLevel.Class::class, "classes", classId) - return firClass?.symbol ?: super.generateClassLikeDeclaration(classId) + val x = 0 + return if (!templateCompiler.compiling) { + val firClass: FirClass? = + if (!classId.isNestedClass) + invokeMeta(true, metaContext(null), emptyList(), Meta.Generate.TopLevel.Class::class, "classes", classId) + else + invokeMeta( + true, + metaContext(null), + emptyList(), + Meta.Generate.Members.NestedClasses::class, + "nestedClasses", + classId + ) + firClass?.symbol ?: super.generateClassLikeDeclaration(classId) + } else null } override fun generateConstructors(context: MemberGenerationContext): List { return if (context.owner.isMetaAnnotated()) { val annotations = context.owner.fir.metaAnnotations(session) val constructors: List? = - invokeMeta(metaContext(context), annotations, Meta.Generate.Members.Constructors::class, "constructors", context) + invokeMeta( + false, + metaContext(context), + annotations, + Meta.Generate.Members.Constructors::class, + "constructors", + context + ) constructors?.map { it.symbol } ?: super.generateConstructors(context) } else super.generateConstructors(context) } @@ -81,8 +95,8 @@ class FirMetaCodegenExtension( val superType = Meta.Generate.Members.Functions::class val metaAnnotations = context.owner.fir.metaAnnotations(session) val functions: List? = - invokeMeta(metaContext(context), metaAnnotations, superType, "functions", callableId, context) - ?: invokeMeta(metaContext(context), metaAnnotations, superType, "functions", context) + invokeMeta(false, metaContext(context), metaAnnotations, superType, "functions", callableId, context) + ?: invokeMeta(false, metaContext(context), metaAnnotations, superType, "functions", context) val decls = context.owner.fir.declarations as? MutableList val patched = patchedfunctions(functions, callableId, context) @@ -121,8 +135,8 @@ class FirMetaCodegenExtension( val superType = Meta.Generate.Members.Properties::class val metaAnnotations = context.owner.fir.metaAnnotations(session) val properties: List? = - invokeMeta(metaContext(context), metaAnnotations, superType, "properties", callableId, context) - ?: invokeMeta(metaContext(context), metaAnnotations, superType, "properties", context) + invokeMeta(false, metaContext(context), metaAnnotations, superType, "properties", callableId, context) + ?: invokeMeta(false, metaContext(context), metaAnnotations, superType, "properties", context) properties?.map { it.symbol } ?: super.generateProperties(callableId, context) } else super.generateProperties(callableId, context) } @@ -135,6 +149,7 @@ class FirMetaCodegenExtension( fun functions(classSymbol: FirClassSymbol<*>): Set? = if (classSymbol.isMetaAnnotated()) invokeMeta( + false, metaContext(null), classSymbol.fir.metaAnnotations(session), Meta.Generate.Members.Functions::class, @@ -148,6 +163,7 @@ class FirMetaCodegenExtension( fun properties(classSymbol: FirClassSymbol<*>): Set? = if (classSymbol.isMetaAnnotated()) invokeMeta( + false, metaContext(null), classSymbol.fir.metaAnnotations(session), Meta.Generate.Members.Properties::class, @@ -159,6 +175,7 @@ class FirMetaCodegenExtension( fun constructors(classSymbol: FirClassSymbol<*>): Set? = if (classSymbol.isMetaAnnotated()) invokeMeta( + false, metaContext(null), classSymbol.fir.metaAnnotations(session), Meta.Generate.Members.Constructors::class, @@ -168,27 +185,29 @@ class FirMetaCodegenExtension( else null fun nestedClasses(classSymbol: FirClassSymbol<*>): Set? = - if (classSymbol.isMetaAnnotated()) - invokeMeta( - metaContext(null), - classSymbol.fir.metaAnnotations(session), - Meta.Generate.Members.NestedClasses::class, - "nestedClasses", - classSymbol, - ) - else null + //if (classSymbol.isMetaAnnotated()) // TODO() can't lookup annotations on this phases are they are not resolved + invokeMeta( + true, // can't resolve annotations here + metaContext(null), + classSymbol.fir.metaAnnotations(session), + Meta.Generate.Members.NestedClasses::class, + "nestedClasses", + classSymbol, + ) + // else null override fun getNestedClassifiersNames(classSymbol: FirClassSymbol<*>): Set = nestedClasses(classSymbol).orEmpty() fun topLevelFunctions(): Set? = - invokeMeta(metaContext(null), emptyList(), Meta.Generate.TopLevel.Functions::class, "functions") + // TODO maybe in all top levels we can't resolve annotations and need a global approach + invokeMeta(false, metaContext(null), emptyList(), Meta.Generate.TopLevel.Functions::class, "functions") fun topLevelClasses(): Set? = - invokeMeta(metaContext(null), emptyList(), Meta.Generate.TopLevel.Class::class, "classes") + invokeMeta(true, metaContext(null), emptyList(), Meta.Generate.TopLevel.Class::class, "classes") fun topLevelProperties(): Set? = - invokeMeta(metaContext(null), emptyList(), Meta.Generate.TopLevel.Properties::class, "properties") + invokeMeta(false, metaContext(null), emptyList(), Meta.Generate.TopLevel.Properties::class, "properties") override fun getTopLevelCallableIds(): Set = topLevelProperties().orEmpty() + topLevelFunctions().orEmpty() @@ -200,6 +219,7 @@ class FirMetaCodegenExtension( return true } + val metaAnnotatedPredicate: DeclarationPredicate get() = DeclarationPredicate.create { metaAnnotated(AnnotationFqn("arrow.meta.Meta")) } diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/transformers/FirMetaTransformer.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/transformers/FirMetaTransformer.kt index 500f643..a98209e 100644 --- a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/transformers/FirMetaTransformer.kt +++ b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/transformers/FirMetaTransformer.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.resolve.fqName import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.util.capitalizeDecapitalize.decapitalizeAsciiOnly @@ -20,11 +21,10 @@ class FirMetaTransformer( private val session: FirSession, val templateCompiler: TemplateCompiler, val metaTargets: List, val checkerContext: CheckerContext, val reporter: DiagnosticReporter, -) : FirTransformer() { - - val metaContext = FirMetaCheckerContext(templateCompiler, session, checkerContext, reporter) +) : FirTransformer() { private fun invokeMeta( + context: FirDeclaration, arg: E ): FirAnnotationContainer? { if (templateCompiler.compiling) return null @@ -34,6 +34,7 @@ class FirMetaTransformer( val dispatchers = metaClasses.mapNotNull { val methodName = it.java.simpleName.decapitalizeAsciiOnly() MetaTarget.find( + false, metaAnnotations.mapNotNull { it.fqName(session)?.asString() }.toSet(), methodName, it, @@ -45,17 +46,20 @@ class FirMetaTransformer( val result: FirAnnotationContainer? = dispatchers.fold(null) { out: FirAnnotationContainer?, target: MetaTarget -> + val metaContext = FirMetaCheckerContext(templateCompiler, session, checkerContext, reporter, context) out ?: target.method.invoke(target.companion.objectInstance, metaContext, arg) as? FirAnnotationContainer } return result } - override fun transformElement(element: E, data: Unit): E { - element.transformChildren(this, data) - return if (element is FirAnnotationContainer) { - invokeMeta(element) as E? ?: element + override fun transformElement(element: E, data: FirDeclaration): E { + val result = if (element is FirAnnotationContainer) { + invokeMeta(data, element) ?: element } else element + //val context = element as? FirDeclaration ?: data + result.transformChildren(this, data) + return result as E } } diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/targets/MetaInvoke.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/targets/MetaInvoke.kt index 8e34f07..d914f36 100644 --- a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/targets/MetaInvoke.kt +++ b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/targets/MetaInvoke.kt @@ -9,6 +9,7 @@ import kotlin.reflect.KClass class MetaInvoke(val session: FirSession, val metaTargets: List) { inline operator fun invoke( + unresolvedAnnotations: Boolean, metaContext: FirMetaContext, annotations: List, superType: KClass<*>, @@ -20,6 +21,7 @@ class MetaInvoke(val session: FirSession, val metaTargets: List) { val args = listOf(In1::class, In2::class, In3::class) val retType = Out::class return MetaTarget.find( + unresolvedAnnotations, annotations.mapNotNull { it.fqName(session)?.asString() }.toSet(), methodName, superType, @@ -33,6 +35,7 @@ class MetaInvoke(val session: FirSession, val metaTargets: List) { } inline operator fun invoke( + unresolvedAnnotations: Boolean, metaContext: FirMetaContext, annotations: List, superType: KClass<*>, @@ -41,6 +44,7 @@ class MetaInvoke(val session: FirSession, val metaTargets: List) { val args = emptyList>() val retType = Out::class return MetaTarget.find( + unresolvedAnnotations, annotations.mapNotNull { it.fqName(session)?.asString() }.toSet(), methodName, superType, @@ -55,6 +59,7 @@ class MetaInvoke(val session: FirSession, val metaTargets: List) { } inline operator fun invoke( + unresolvedAnnotations: Boolean, metaContext: FirMetaContext, annotations: List, superType: KClass<*>, @@ -64,6 +69,7 @@ class MetaInvoke(val session: FirSession, val metaTargets: List) { val args = listOf(In::class) val retType = Out::class return MetaTarget.find( + unresolvedAnnotations, annotations.mapNotNull { it.fqName(session)?.asString() }.toSet(), methodName, superType, @@ -78,6 +84,7 @@ class MetaInvoke(val session: FirSession, val metaTargets: List) { } inline operator fun invoke( + unresolvedAnnotations: Boolean, metaContext: FirMetaContext, annotations: List, superType: KClass<*>, @@ -88,6 +95,7 @@ class MetaInvoke(val session: FirSession, val metaTargets: List) { val args = listOf(In1::class, In2::class) val retType = Out::class return MetaTarget.find( + unresolvedAnnotations, annotations.mapNotNull { it.fqName(session)?.asString() }.toSet(), methodName, superType, diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/targets/MetaTarget.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/targets/MetaTarget.kt index 5b40d76..b26ec8f 100644 --- a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/targets/MetaTarget.kt +++ b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/targets/MetaTarget.kt @@ -18,6 +18,7 @@ data class MetaTarget( companion object { fun find( + unresolvedAnnotations: Boolean, annotations : Set, methodName: String, supertype: KClass<*>?, @@ -26,7 +27,7 @@ data class MetaTarget( targets: List ): MetaTarget? = targets.find { - (it.annotation.java.canonicalName in annotations) && + (unresolvedAnnotations || it.annotation.java.canonicalName in annotations) && (supertype == null || it.companion.allSuperclasses.any { it == supertype }) && diff --git a/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.ir.txt b/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.ir.txt new file mode 100644 index 0000000..91e2162 --- /dev/null +++ b/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.ir.txt @@ -0,0 +1,172 @@ +FILE fqName:foo.bar fileName:/reflect_test.kt + CLASS ANNOTATION_CLASS name:Test modality:OPEN visibility:public superTypes:[kotlin.Annotation] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:foo.bar.Test + CONSTRUCTOR visibility:public <> () returnType:foo.bar.Test [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS ANNOTATION_CLASS name:Test modality:OPEN visibility:public superTypes:[kotlin.Annotation]' + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in kotlin.Annotation + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int [fake_override] declared in kotlin.Annotation + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String [fake_override] declared in kotlin.Annotation + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:Sample modality:FINAL visibility:public [data] superTypes:[kotlin.Any] + annotations: + Reflect + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:foo.bar.Sample + CONSTRUCTOR visibility:public <> (name:kotlin.String, age:kotlin.Int) returnType:foo.bar.Sample [primary] + VALUE_PARAMETER name:name index:0 type:kotlin.String + VALUE_PARAMETER name:age index:1 type:kotlin.Int + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Sample modality:FINAL visibility:public [data] superTypes:[kotlin.Any]' + PROPERTY name:name visibility:public modality:FINAL [val] + FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final] + EXPRESSION_BODY + GET_VAR 'name: kotlin.String declared in foo.bar.Sample.' type=kotlin.String origin=INITIALIZE_PROPERTY_FROM_PARAMETER + FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> ($this:foo.bar.Sample) returnType:kotlin.String + correspondingProperty: PROPERTY name:name visibility:public modality:FINAL [val] + $this: VALUE_PARAMETER name: type:foo.bar.Sample + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun (): kotlin.String declared in foo.bar.Sample' + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.' type=foo.bar.Sample origin=null + PROPERTY name:age visibility:public modality:FINAL [val] + FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final] + EXPRESSION_BODY + GET_VAR 'age: kotlin.Int declared in foo.bar.Sample.' type=kotlin.Int origin=INITIALIZE_PROPERTY_FROM_PARAMETER + FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> ($this:foo.bar.Sample) returnType:kotlin.Int + correspondingProperty: PROPERTY name:age visibility:public modality:FINAL [val] + $this: VALUE_PARAMETER name: type:foo.bar.Sample + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in foo.bar.Sample' + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.' type=foo.bar.Sample origin=null + FUN name:component1 visibility:public modality:FINAL <> ($this:foo.bar.Sample) returnType:kotlin.String [operator] + $this: VALUE_PARAMETER name: type:foo.bar.Sample + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun component1 (): kotlin.String [operator] declared in foo.bar.Sample' + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.component1' type=foo.bar.Sample origin=null + FUN name:component2 visibility:public modality:FINAL <> ($this:foo.bar.Sample) returnType:kotlin.Int [operator] + $this: VALUE_PARAMETER name: type:foo.bar.Sample + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun component2 (): kotlin.Int [operator] declared in foo.bar.Sample' + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.component2' type=foo.bar.Sample origin=null + FUN name:copy visibility:public modality:FINAL <> ($this:foo.bar.Sample, name:kotlin.String, age:kotlin.Int) returnType:foo.bar.Sample + $this: VALUE_PARAMETER name: type:foo.bar.Sample + VALUE_PARAMETER name:name index:0 type:kotlin.String + EXPRESSION_BODY + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.copy' type=foo.bar.Sample origin=null + VALUE_PARAMETER name:age index:1 type:kotlin.Int + EXPRESSION_BODY + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.copy' type=foo.bar.Sample origin=null + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun copy (name: kotlin.String, age: kotlin.Int): foo.bar.Sample declared in foo.bar.Sample' + CONSTRUCTOR_CALL 'public constructor (name: kotlin.String, age: kotlin.Int) [primary] declared in foo.bar.Sample' type=foo.bar.Sample origin=null + name: GET_VAR 'name: kotlin.String declared in foo.bar.Sample.copy' type=kotlin.String origin=null + age: GET_VAR 'age: kotlin.Int declared in foo.bar.Sample.copy' type=kotlin.Int origin=null + FUN GENERATED_DATA_CLASS_MEMBER name:equals visibility:public modality:OPEN <> ($this:foo.bar.Sample, other:kotlin.Any?) returnType:kotlin.Boolean + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER GENERATED_DATA_CLASS_MEMBER name: type:foo.bar.Sample + VALUE_PARAMETER GENERATED_DATA_CLASS_MEMBER name:other index:0 type:kotlin.Any? + BLOCK_BODY + WHEN type=kotlin.Unit origin=null + BRANCH + if: CALL 'public final fun EQEQEQ (arg0: kotlin.Any?, arg1: kotlin.Any?): kotlin.Boolean declared in kotlin.internal.ir' type=kotlin.Boolean origin=EQEQEQ + arg0: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.equals' type=foo.bar.Sample origin=null + arg1: GET_VAR 'other: kotlin.Any? declared in foo.bar.Sample.equals' type=kotlin.Any? origin=null + then: RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in foo.bar.Sample' + CONST Boolean type=kotlin.Boolean value=true + WHEN type=kotlin.Unit origin=null + BRANCH + if: TYPE_OP type=kotlin.Boolean origin=NOT_INSTANCEOF typeOperand=foo.bar.Sample + GET_VAR 'other: kotlin.Any? declared in foo.bar.Sample.equals' type=kotlin.Any? origin=null + then: RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in foo.bar.Sample' + CONST Boolean type=kotlin.Boolean value=false + VAR IR_TEMPORARY_VARIABLE name:tmp_0 type:foo.bar.Sample [val] + TYPE_OP type=foo.bar.Sample origin=CAST typeOperand=foo.bar.Sample + GET_VAR 'other: kotlin.Any? declared in foo.bar.Sample.equals' type=kotlin.Any? origin=null + WHEN type=kotlin.Unit origin=null + BRANCH + if: CALL 'public final fun not (): kotlin.Boolean [operator] declared in kotlin.Boolean' type=kotlin.Boolean origin=EXCLEQ + $this: CALL 'public final fun EQEQ (arg0: kotlin.Any?, arg1: kotlin.Any?): kotlin.Boolean declared in kotlin.internal.ir' type=kotlin.Boolean origin=EXCLEQ + arg0: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.equals' type=foo.bar.Sample origin=null + arg1: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null + receiver: GET_VAR 'val tmp_0: foo.bar.Sample [val] declared in foo.bar.Sample.equals' type=foo.bar.Sample origin=null + then: RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in foo.bar.Sample' + CONST Boolean type=kotlin.Boolean value=false + WHEN type=kotlin.Unit origin=null + BRANCH + if: CALL 'public final fun not (): kotlin.Boolean [operator] declared in kotlin.Boolean' type=kotlin.Boolean origin=EXCLEQ + $this: CALL 'public final fun EQEQ (arg0: kotlin.Any?, arg1: kotlin.Any?): kotlin.Boolean declared in kotlin.internal.ir' type=kotlin.Boolean origin=EXCLEQ + arg0: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.equals' type=foo.bar.Sample origin=null + arg1: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null + receiver: GET_VAR 'val tmp_0: foo.bar.Sample [val] declared in foo.bar.Sample.equals' type=foo.bar.Sample origin=null + then: RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in foo.bar.Sample' + CONST Boolean type=kotlin.Boolean value=false + RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in foo.bar.Sample' + CONST Boolean type=kotlin.Boolean value=true + FUN GENERATED_DATA_CLASS_MEMBER name:hashCode visibility:public modality:OPEN <> ($this:foo.bar.Sample) returnType:kotlin.Int + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER GENERATED_DATA_CLASS_MEMBER name: type:foo.bar.Sample + BLOCK_BODY + VAR name:result type:kotlin.Int [var] + CALL 'public open fun hashCode (): kotlin.Int [fake_override] declared in kotlin.String' type=kotlin.Int origin=null + $this: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.hashCode' type=foo.bar.Sample origin=null + SET_VAR 'var result: kotlin.Int [var] declared in foo.bar.Sample.hashCode' type=kotlin.Unit origin=EQ + CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null + $this: CALL 'public final fun times (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null + $this: GET_VAR 'var result: kotlin.Int [var] declared in foo.bar.Sample.hashCode' type=kotlin.Int origin=null + other: CONST Int type=kotlin.Int value=31 + other: CALL 'public open fun hashCode (): kotlin.Int [fake_override] declared in kotlin.Int' type=kotlin.Int origin=null + $this: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.hashCode' type=foo.bar.Sample origin=null + RETURN type=kotlin.Nothing from='public open fun hashCode (): kotlin.Int declared in foo.bar.Sample' + GET_VAR 'var result: kotlin.Int [var] declared in foo.bar.Sample.hashCode' type=kotlin.Int origin=null + FUN GENERATED_DATA_CLASS_MEMBER name:toString visibility:public modality:OPEN <> ($this:foo.bar.Sample) returnType:kotlin.String + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER GENERATED_DATA_CLASS_MEMBER name: type:foo.bar.Sample + BLOCK_BODY + RETURN type=kotlin.Nothing from='public open fun toString (): kotlin.String declared in foo.bar.Sample' + STRING_CONCATENATION type=kotlin.String + CONST String type=kotlin.String value="Sample(" + CONST String type=kotlin.String value="name=" + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.toString' type=foo.bar.Sample origin=null + CONST String type=kotlin.String value=", " + CONST String type=kotlin.String value="age=" + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null + receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.toString' type=foo.bar.Sample origin=null + CONST String type=kotlin.String value=")" + FUN name:box visibility:public modality:FINAL <> () returnType:kotlin.String + BLOCK_BODY + VAR name:x type:kotlin.reflect.KClass [val] + CLASS_REFERENCE 'CLASS CLASS name:Sample modality:FINAL visibility:public [data] superTypes:[kotlin.Any]' type=kotlin.reflect.KClass + RETURN type=kotlin.Nothing from='public final fun box (): kotlin.String declared in foo.bar' + WHEN type=kotlin.String origin=IF + BRANCH + if: TYPE_OP type=kotlin.Boolean origin=INSTANCEOF typeOperand=arrow.meta.samples.CompileTimeReflected<*> + GET_VAR 'val x: kotlin.reflect.KClass [val] declared in foo.bar.box' type=kotlin.reflect.KClass origin=null + then: CONST String type=kotlin.String value="OK" + BRANCH + if: CONST Boolean type=kotlin.Boolean value=true + then: CONST String type=kotlin.String value="Fail" +FILE fqName:foo.bar.some.additional.files fileName:/SomeFile.kt diff --git a/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.txt b/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.txt new file mode 100644 index 0000000..f3140ec --- /dev/null +++ b/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.txt @@ -0,0 +1,39 @@ +FILE: reflect_test.kt + package foo.bar + + public final annotation class Test : R|kotlin/Annotation| { + public constructor(): R|foo/bar/Test| { + super() + } + + } + @R|arrow/meta/samples/Reflect|() public final data class Sample : R|kotlin/Any| { + public constructor(name: R|kotlin/String|, age: R|kotlin/Int|): R|foo/bar/Sample| { + super() + } + + public final val name: R|kotlin/String| = R|/name| + public get(): R|kotlin/String| + + public final val age: R|kotlin/Int| = R|/age| + public get(): R|kotlin/Int| + + public final operator fun component1(): R|kotlin/String| + + public final operator fun component2(): R|kotlin/Int| + + public final fun copy(name: R|kotlin/String| = this@R|foo/bar/Sample|.R|foo/bar/Sample.name|, age: R|kotlin/Int| = this@R|foo/bar/Sample|.R|foo/bar/Sample.age|): R|foo/bar/Sample| + + } + public final fun box(): R|kotlin/String| { + lval x: R|kotlin/reflect/KClass| = @R|arrow/meta/samples/Reflect|() (Q|foo/bar/Sample|) + ^box when () { + (R|/x| is R|arrow/meta/samples/CompileTimeReflected<*>|) -> { + String(OK) + } + else -> { + String(Fail) + } + } + + } diff --git a/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.kt b/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.kt new file mode 100644 index 0000000..6cffb32 --- /dev/null +++ b/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.kt @@ -0,0 +1,19 @@ +package foo.bar + +import arrow.meta.samples.Reflect +import arrow.meta.samples.CompileTimeReflected +import kotlin.reflect.KClass + +annotation class Test + +@Reflect +data class Sample(val name: String, val age: Int) + +fun box(): String { + val x = @Reflect Sample::class + return if (x is CompileTimeReflected<*>) { + "OK" + } else { + "Fail" + } +} diff --git a/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/BoxTestGenerated.java b/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/BoxTestGenerated.java index c5e3cb9..c96350e 100644 --- a/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/BoxTestGenerated.java +++ b/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/BoxTestGenerated.java @@ -40,6 +40,12 @@ public void testProduct_test_expected() throws Exception { runTest("src/testData/box/product_test_expected.kt"); } + @Test + @TestMetadata("reflect_test.kt") + public void testReflect_test() throws Exception { + runTest("src/testData/box/reflect_test.kt"); + } + @Test @TestMetadata("sample_test.kt") public void testSample_test() throws Exception { diff --git a/sandbox/src/main/kotlin/CallGraph.kt b/sandbox/src/main/kotlin/CallGraph.kt new file mode 100644 index 0000000..6f2425b --- /dev/null +++ b/sandbox/src/main/kotlin/CallGraph.kt @@ -0,0 +1,14 @@ +package sample + +import arrow.meta.samples.Pure +import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn + +@Pure +fun foo() : Int { + bar() + return 0 +} + +fun bar() { + println("io") +} From dd23f07f07b2150721ea53a81a2a8d23ede388d8 Mon Sep 17 00:00:00 2001 From: raulraja Date: Sat, 31 Dec 2022 16:20:15 +0100 Subject: [PATCH 2/8] add failing test --- .../src/main/kotlin/MetaModule.kt | 10 +- .../src/main/kotlin/arrow/meta/MetaContext.kt | 4 - .../kotlin/arrow/meta/TemplateCompiler.kt | 50 +- .../arrow/meta/macros/DeclarationMacro.kt | 181 --- .../kotlin/arrow/meta/macros/Transform.kt | 35 - .../main/kotlin/arrow/meta/module/Module.kt | 74 - .../meta/plugins/AssignmentTransformer.kt | 20 - .../kotlin/arrow/meta/plugins/Checkers.kt | 36 - .../arrow/meta/plugins/CompilerPlugin.kt | 5 - .../meta/plugins/ExpressionResolution.kt | 21 - .../arrow/meta/plugins/FrontendPlugin.kt | 34 - .../kotlin/arrow/meta/plugins/Generation.kt | 80 -- .../arrow/meta/plugins/MetaFirTransformer.kt | 745 ----------- .../meta/plugins/SAMConversionTransformer.kt | 20 - .../arrow/meta/plugins/ScriptConfigurator.kt | 20 - .../arrow/meta/plugins/StatusTransformer.kt | 24 - .../kotlin/arrow/meta/plugins/Supertypes.kt | 32 - .../kotlin/arrow/meta/plugins/Transformer.kt | 1192 ----------------- .../arrow/meta/plugins/TypeAttributes.kt | 24 - .../arrow/meta/plugins/example/ExampleFull.kt | 77 -- .../main/kotlin/arrow/meta/samples/Reflect.kt | 24 +- .../fir/FirArrowReflectExtensionRegistrar.kt | 186 +-- .../CompilerPluginGenerationExtension.kt | 58 - .../fir/transformers/FirMetaTransformer.kt | 8 +- .../src/testData/box/reflect_test.fir.ir.txt | 172 --- .../src/testData/box/reflect_test.fir.txt | 39 - .../src/testData/box/reflect_test.kt | 19 - .../testData/diagnostics/reflect_test.fir.txt | 16 + .../src/testData/diagnostics/reflect_test.kt | 6 + .../plugin/runners/BoxTestGenerated.java | 6 - .../runners/DiagnosticTestGenerated.java | 6 + 31 files changed, 64 insertions(+), 3160 deletions(-) delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/DeclarationMacro.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/Transform.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/AssignmentTransformer.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Checkers.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/CompilerPlugin.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ExpressionResolution.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/FrontendPlugin.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Generation.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/MetaFirTransformer.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/SAMConversionTransformer.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ScriptConfigurator.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/StatusTransformer.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Supertypes.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Transformer.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/TypeAttributes.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/example/ExampleFull.kt delete mode 100644 arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/CompilerPluginGenerationExtension.kt delete mode 100644 arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.ir.txt delete mode 100644 arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.txt delete mode 100644 arrow-reflect-compiler-plugin/src/testData/box/reflect_test.kt create mode 100644 arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.fir.txt create mode 100644 arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.kt diff --git a/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt b/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt index 2191503..f98c3ca 100644 --- a/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt +++ b/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt @@ -1,22 +1,14 @@ package arrow.meta.module.impl -import arrow.meta.macros.MyMacro -import arrow.meta.module.Compiler import arrow.meta.module.Module -import arrow.meta.module.increment import arrow.meta.samples.* interface MetaModule: Module { - val reflect: Reflect val increment: Increment val product: Product val log: Log val decorator: Decorator val pure: Pure - val myMacro : MyMacro - //val optics: Optics + val reflect: Reflect } -interface MetaModule2: Module { - val increment get() = Compiler::increment -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/MetaContext.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/MetaContext.kt index 254a861..31e3731 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/MetaContext.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/MetaContext.kt @@ -1,6 +1,5 @@ package arrow.meta -import arrow.meta.macros.Kotlin import org.intellij.lang.annotations.Language import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities @@ -141,9 +140,6 @@ abstract class FirMetaContext( fun source(@Language("kotlin") source: String): String = source - inline fun kotlin(@Language("kotlin") value: String): Kotlin = - Kotlin(Out::class, value) - inline fun compile(@Language("kotlin") source: String): Fir { val results = templateCompiler.compileSource( this@FirMetaContext as? FirMetaCheckerContext, diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/TemplateCompiler.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/TemplateCompiler.kt index cca7075..d1cc259 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/TemplateCompiler.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/TemplateCompiler.kt @@ -2,6 +2,7 @@ package arrow.meta import com.intellij.psi.PsiDocumentManager import com.intellij.psi.PsiFile +import org.jetbrains.kotlin.KtInMemoryTextSourceFile import org.jetbrains.kotlin.KtIoFileSourceFile import org.jetbrains.kotlin.KtSourceFile import org.jetbrains.kotlin.backend.jvm.JvmIrDeserializerImpl @@ -101,27 +102,20 @@ class TemplateCompiler( compiling = true try { val next = counter.incrementAndGet() - val fileName = "meta.template_$next.kt" - //println("parsing source:\n$source") + //val fileName = "meta.template_$next.kt" + println("parsing source:\n$source") println("session: ${session::class}") - val sourceFile = File(templatesFolder, fileName) - val allSources = - listOf( - sourceFile.also { - it.writeText(source) - } - ) val outputs: ArrayList = arrayListOf() val irOutput: ArrayList = arrayListOf() val messageCollector: MessageCollector = MessageCollector.NONE for (module in chunk) { val moduleConfiguration = projectConfiguration//.applyModuleProperties(module, buildFile) val context = CompilationContext( - allSources, + source, messageCollector, moduleConfiguration ) - val result = context.compileModule(sourceFile, metaCheckerContext, scopeDeclarations) + val result = context.compileModule(metaCheckerContext, scopeDeclarations) val templateResult = result ?: return TemplateResult(emptyList(), emptyList()) outputs += templateResult @@ -138,21 +132,16 @@ class TemplateCompiler( } } - private fun CompilationContext.compileModule( - sourceFile: File, - metaCheckerContext: FirMetaCheckerContext?, - scopeDeclarations: List - ): FirResult? { + private fun CompilationContext.compileModule(metaCheckerContext: FirMetaCheckerContext?, scopeDeclarations: List): FirResult? { ProgressIndicatorAndCompilationCanceledStatus.checkCanceled() + val renderDiagnosticNames = true val diagnosticsReporter = DiagnosticReporterFactory.createPendingReporter() - val firResult = runFrontend(allSources, diagnosticsReporter, scopeDeclarations) - if (firResult == null) { - val (source, mappings) = sourceFile.inputStream().reader().use { it.readSourceFileWithMapping() } - diagnosticsReporter.diagnosticsByFilePath.entries.forEach { (path, diagnostics) -> - diagnostics.forEach { - val (line, column) = mappings.getLineAndColumnByOffset(it.element.startOffset) - println("error: file://${sourceFile.absolutePath}:$line:$column [" + it.factory.name + "] " + it.factory.ktRenderer.render(it)) - } + val firResult = runFrontend(source, diagnosticsReporter, scopeDeclarations) + val diagnosticsContext = metaCheckerContext?.checkerContext + if (firResult == null && diagnosticsContext != null) { + diagnosticsReporter.diagnostics.forEach { + metaCheckerContext.diagnosticReporter.report(it, diagnosticsContext) + println("error: [" + it.factory.name + "] " + it.factory.ktRenderer.render(it)) } return null } @@ -172,13 +161,15 @@ class TemplateCompiler( } private fun runFrontend( - files: List, + source: String, diagnosticsReporter: BaseDiagnosticsCollector, scopeDeclarations: List, ): FirResult? { val syntaxErrors = false val scope = ScopeSession() - val rawFir = session.buildFirViaLightTree(files.map { KtIoFileSourceFile(it) }) // ,.buildFirFromKtFiles(ktFiles) + val next = counter.incrementAndGet() + val fileName = "meta.template_$next.kt" + val rawFir = session.buildFirViaLightTree(listOf(KtInMemoryTextSourceFile(fileName, null, source))) // ,.buildFirFromKtFiles(ktFiles) val (scopeSession, fir) = session.runResolution(rawFir, scope, scopeDeclarations) session.runCheckers(scopeSession, fir, diagnosticsReporter) return if (syntaxErrors || diagnosticsReporter.hasErrors) null else FirResult( @@ -274,7 +265,7 @@ class TemplateCompiler( } private class CompilationContext( - val allSources: List, + val source: String, val messageCollector: MessageCollector, val moduleConfiguration: CompilerConfiguration ) @@ -329,21 +320,22 @@ fun FirResolvePhase.createCompilerProcessorByPhase( } } -@OptIn(AdapterForResolveProcessor::class) class FirBodyResolveProcessor( session: FirSession, scopeSession: ScopeSession, scopeDeclarations: List ) : FirTransformerBasedResolveProcessor(session, scopeSession, FirResolvePhase.BODY_RESOLVE) { + override val transformer = FirBodyResolveTransformerAdapter(session, scopeSession, scopeDeclarations) } -@AdapterForResolveProcessor + class FirBodyResolveTransformerAdapter( session: FirSession, scopeSession: ScopeSession, scopeDeclarations: List ) : FirTransformer() { + @OptIn(PrivateForInline::class) private val transformer = FirBodyResolveTransformer( session, diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/DeclarationMacro.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/DeclarationMacro.kt deleted file mode 100644 index e282a1c..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/DeclarationMacro.kt +++ /dev/null @@ -1,181 +0,0 @@ -package arrow.meta.macros - -import arrow.meta.Meta -import arrow.meta.plugins.* -import org.jetbrains.kotlin.KtInMemoryTextSourceFile -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol -import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.extensions.AnnotationFqn -import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate -import org.jetbrains.kotlin.fir.extensions.predicate.LookupPredicate -import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider -import org.jetbrains.kotlin.fir.pipeline.buildFirViaLightTree -import org.jetbrains.kotlin.fir.resolve.fqName -import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -import org.jetbrains.kotlin.fir.symbols.SymbolInternals - -typealias ClassMacro = DeclarationMacro - -@OptIn(SymbolInternals::class) -abstract class DeclarationMacro(annotation: Annotation) : FrontendPlugin.Builder() { - - override val plugins: Sequence<(FirSession) -> FrontendPlugin> - get() { - return super.plugins + sequence { - yield( - Generation { - register(macroPredicate) - session.transformations.forEach { transformation -> - when (transformation) { - is Transform.Generate.Member.Function -> { - callableNamesForClass = { classSymbol -> - val kotlin = transformation.invoke(classSymbol.fir, null) - val fir = session.buildFirViaLightTree( - listOf( - KtInMemoryTextSourceFile( - "topLevelCallableIds.map.kt", null, kotlin.value - ) - ) - ) - val decls = fir.firstOrNull()?.declarations?.filterIsInstance() - ?.map { it.symbol.callableId.callableName } - decls?.toSet().orEmpty() - } - } - - is Transform.Generate.Member.NestedClass -> TODO() - is Transform.Generate.Member.Property -> TODO() - is Transform.Generate.TopLevel.Class -> TODO() - is Transform.Generate.TopLevel.Function -> TODO() - is Transform.Generate.TopLevel.Property -> TODO() - is Transform.Replace -> TODO() - } - } - } - ) - } - } -// init { -// +Supertypes { -// registerPredicates = register(macroPredicate) -// } -// +StatusTransformer { -// registerPredicates = register(macroPredicate) -// } -// +Transformer { -// registerPredicates = register(macroPredicate) -// } -// +Generation { -// registerPredicates = register(macroPredicate) -// session.transformations.forEach { t -> -// when (t) { -// is Transform.Generate.Member.Function -> { -// callableNamesForClass = { classSymbol -> -// val kotlin = t.invoke(classSymbol.fir, null) -// -// TODO() -// } -// } -// is Transform.Generate.Member.NestedClass -> TODO() -// is Transform.Generate.Member.Property -> TODO() -// is Transform.Generate.TopLevel.Class -> TODO() -// is Transform.Generate.TopLevel.Function -> TODO() -// is Transform.Generate.TopLevel.Property -> TODO() -// is Transform.Replace -> TODO() -// } -// } -// } -// } - - val annotationFqName = AnnotationFqn(annotation.annotationClass.java.canonicalName) - - val macroPredicate: DeclarationPredicate = DeclarationPredicate.create { - metaAnnotated(annotationFqName) - } - - fun FirSession.macroSymbols(): List> = - predicateBasedProvider.getSymbolsByPredicate(LookupPredicate.create { annotated(annotationFqName) }) - - fun FirSession.macroInstances(): List> = macroSymbols().mapNotNull { - val macroAnnotation = it.annotations.firstOrNull { it.fqName(this) == annotationFqName } - val companionFqName = - macroAnnotation?.annotationTypeRef?.toRegularClassSymbol(this)?.fir?.companionObjectSymbol?.classId?.asFqNameString() - val companionInstance = Class.forName(companionFqName).kotlin.objectInstance as? DeclarationMacro<*> - companionInstance as? DeclarationMacro - } - - val FirSession.transformations: List> - get() = - macroInstances().map { it.run { transform() } } - - - // transformations.forEach { transform -> -// when (transform) { -// is Transform.Generate -> +Generation { -// registerPredicates = register(macroPredicate) -// when (transform) { -// is Transform.Generate.Member -> TODO() -// is Transform.Generate.TopLevel -> { -// when (transform) { -// is Transform.Generate.TopLevel.Class -> { -// -// } -// -// is Transform.Generate.TopLevel.Function -> { -// topLevelCallableIds = { -//// val source = transform.invoke(null) -//// val fir = session.buildFirViaLightTree( -//// listOf( -//// KtInMemoryTextSourceFile( -//// "topLevelCallableIds.map.kt", null, source.value -//// ) -//// ) -//// ) -//// val decls = fir.firstOrNull()?.declarations?.filterIsInstance() -//// ?.map { it.symbol.callableId } -//// decls?.toSet().orEmpty() -// TODO() -// } -// functions = { callableId, memberGenerationContext -> -// TODO() -// } -// } -// -// is Transform.Generate.TopLevel.Property -> TODO() -// is Transform.Generate.Member.Function -> TODO() -// is Transform.Generate.Member.NestedClass -> TODO() -// is Transform.Generate.Member.Property -> TODO() -// } -// -// classLikeDeclaration = { -// TODO() -// } -// } -// } -// } -// -// is Transform.Replace -> TODO() -// } -// } - abstract fun transform(): Transform - -} - -@Meta -annotation class MyMacro { - - companion object : ClassMacro(MyMacro()) { - override fun transform(): Transform.Generate.Member.Function = - Transform.Generate.Member.Function { context, callableId -> - Kotlin( - """ - fun foo(): Unit = println("Hello, World!") - """ - ) - } - } -} - -@MyMacro -class Sample diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/Transform.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/Transform.kt deleted file mode 100644 index b921224..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/macros/Transform.kt +++ /dev/null @@ -1,35 +0,0 @@ -package arrow.meta.macros - -import org.intellij.lang.annotations.Language -import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.declarations.FirClass -import org.jetbrains.kotlin.fir.declarations.FirDeclaration -import org.jetbrains.kotlin.fir.declarations.FirProperty -import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction -import org.jetbrains.kotlin.name.CallableId -import org.jetbrains.kotlin.name.ClassId -import kotlin.reflect.KClass - -data class Kotlin (val target: KClass, @Language("kotlin") val value: String) { - override fun toString(): String = - value -} - -inline fun Kotlin(@Language("kotlin") value: String): Kotlin = - Kotlin(E::class, value) - -sealed interface Transform { - class Replace(val invoke: (In) -> Kotlin) : Transform - sealed interface Generate : Transform { - sealed interface TopLevel : Generate { - class Class(val invoke: (In, ClassId?) -> Kotlin) : TopLevel - class Function(val invoke: (In, CallableId?) -> Kotlin) : TopLevel - class Property(val invoke: (In, CallableId?) -> Kotlin) : TopLevel - } - sealed interface Member : Generate { - class NestedClass(val invoke: (In, ClassId?) -> Kotlin) : Member - class Function(val invoke: (In, CallableId?) -> Kotlin) : Member - class Property(val invoke: (In, CallableId?) -> Kotlin) : Member - } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/module/Module.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/module/Module.kt index d662d1a..e4b973d 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/module/Module.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/module/Module.kt @@ -1,77 +1,3 @@ package arrow.meta.module -import arrow.meta.FirMetaCheckerContext -import arrow.meta.FirMetaContext -import arrow.meta.Meta -import org.jetbrains.kotlin.fir.FirAnnotationContainer -import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction -import org.jetbrains.kotlin.fir.declarations.hasAnnotation -import org.jetbrains.kotlin.fir.expressions.FirConstExpression -import org.jetbrains.kotlin.fir.expressions.FirStatement -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.types.ConstantValueKind - interface Module - -inline fun classId(): ClassId { - val klass = A::class - val packageName = klass.java.`package`.name - val shortName = klass.java.simpleName - val isLocal = klass.java.isLocalClass - return ClassId(FqName(packageName), FqName(shortName), isLocal) -} - -inline fun FirAnnotationContainer.annotatedWith(): Boolean = - annotations.hasAnnotation(classId()) - -fun interface Transform { - fun FirMetaContext.transform(element: In): Out -} - -@Target(AnnotationTarget.EXPRESSION, AnnotationTarget.VALUE_PARAMETER) -@Retention(AnnotationRetention.SOURCE) -annotation class Increment - -annotation class AnnotatedWith - -typealias Compiler = FirMetaContext - -//transform macro -@Meta -fun Compiler.increment(@AnnotatedWith constant: FirConstExpression<*>): FirStatement { - check(constant.kind == ConstantValueKind.Int) { - "@Increment only works in constant of type `Int`. found: ${constant.kind.asString}" - } - return compile("${constant} + 1") -} - -object IncrementMacroImpl : Module, Meta.FrontendTransformer.ConstExpression { - override fun FirMetaCheckerContext.constExpression(constExpression: FirConstExpression<*>): FirStatement = - increment(constExpression) -} - -annotation class Test - -@Test -data class Sample(val name: String) - -//generation macro -@Meta -fun Compiler.generationMacro(@Test firClassSymbol: FirClassSymbol<*>): List = - listOf( - compile(""" - fun test(): Unit {} - """.trimIndent()) - ) - -fun main() { - //val x = Sample("f").test() - println(@Increment 0) -} - - - - diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/AssignmentTransformer.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/AssignmentTransformer.kt deleted file mode 100644 index 335efea..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/AssignmentTransformer.kt +++ /dev/null @@ -1,20 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.expressions.FirStatement -import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment - - -interface AssignmentTransformer : FrontendPlugin { - fun transformVariableAssignment(variableAssignment: FirVariableAssignment): FirStatement? - class Builder(override val session: FirSession) : FrontendPlugin.Builder(), AssignmentTransformer { - var transformVariableAssignment: (FirVariableAssignment) -> FirStatement? = { it } - - override fun transformVariableAssignment(variableAssignment: FirVariableAssignment): FirStatement? = - this.transformVariableAssignment(variableAssignment) - } - - companion object { - operator fun invoke(init: Builder.() -> Unit): (FirSession) -> AssignmentTransformer = { Builder(it).apply(init) } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Checkers.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Checkers.kt deleted file mode 100644 index f177f58..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Checkers.kt +++ /dev/null @@ -1,36 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.declarations.FirDeclaration -import org.jetbrains.kotlin.fir.expressions.FirStatement -import org.jetbrains.kotlin.fir.types.FirTypeRef - -interface Checkers : FrontendPlugin { - fun interface Declaration { - fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter) - } - - fun interface Expression { - fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter) - } - - fun interface Type { - fun check(declaration: D, context: CheckerContext, reporter: DiagnosticReporter) - } - - val declarationCheckers: Set> - val expressionCheckers: Set> - val typeCheckers: Set> - - class Builder(override val session: FirSession) : FrontendPlugin.Builder(), Checkers { - override val declarationCheckers: MutableSet> = mutableSetOf() - override val expressionCheckers: MutableSet> = mutableSetOf() - override val typeCheckers: MutableSet> = mutableSetOf() - } - - companion object { - operator fun invoke(init: Builder.() -> Unit): (FirSession) -> Checkers = { Builder(it).apply(init) } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/CompilerPlugin.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/CompilerPlugin.kt deleted file mode 100644 index 3674fd9..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/CompilerPlugin.kt +++ /dev/null @@ -1,5 +0,0 @@ -package arrow.meta.plugins - -interface CompilerPlugin - - diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ExpressionResolution.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ExpressionResolution.kt deleted file mode 100644 index d061de4..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ExpressionResolution.kt +++ /dev/null @@ -1,21 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.expressions.FirFunctionCall -import org.jetbrains.kotlin.fir.types.ConeKotlinType - -interface ExpressionResolution : FrontendPlugin { - fun addNewImplicitReceivers(functionCall: FirFunctionCall): List - - class Builder(override val session: FirSession) : ExpressionResolution, FrontendPlugin.Builder() { - - var newImplicitReceivers: (FirFunctionCall) -> List = { emptyList() } - - override fun addNewImplicitReceivers(functionCall: FirFunctionCall): List = - newImplicitReceivers(functionCall) - } - - companion object { - operator fun invoke(init: Builder.() -> Unit): (FirSession) -> ExpressionResolution = { Builder(it).apply(init) } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/FrontendPlugin.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/FrontendPlugin.kt deleted file mode 100644 index e1486ee..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/FrontendPlugin.kt +++ /dev/null @@ -1,34 +0,0 @@ -package arrow.meta.plugins - -import arrow.meta.Meta -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.extensions.AnnotationFqn -import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar -import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate - -sealed interface FrontendPlugin : CompilerPlugin { - - val session : FirSession - - val metaAnnotatedPredicate: DeclarationPredicate - get() = DeclarationPredicate.create { metaAnnotated(AnnotationFqn(Meta::class.java.canonicalName)) } - - fun FirDeclarationPredicateRegistrar.registerPredicates() { - register(metaAnnotatedPredicate) - } - - open class Builder { - private var compilerPlugins: Sequence<(FirSession) -> FrontendPlugin> = sequenceOf() - operator fun ((FirSession) -> FrontendPlugin).unaryPlus() { - compilerPlugins += this - } - open val plugins: Sequence<(FirSession) -> FrontendPlugin> get() = compilerPlugins - - fun register(macroPredicate: DeclarationPredicate): FirDeclarationPredicateRegistrar.() -> Unit = { - register(macroPredicate) - } - } - companion object { - operator fun invoke(init: Builder.() -> Unit): Builder = Builder().apply(init) - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Generation.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Generation.kt deleted file mode 100644 index 7d2398d..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Generation.kt +++ /dev/null @@ -1,80 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.extensions.MemberGenerationContext -import org.jetbrains.kotlin.fir.symbols.impl.* -import org.jetbrains.kotlin.name.CallableId -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name - -interface Generation : FrontendPlugin { - fun generateClassLikeDeclaration(classId: ClassId): FirClassLikeSymbol<*>? - fun generateConstructors(context: MemberGenerationContext): List - fun generateFunctions(callableId: CallableId, context: MemberGenerationContext?): List - fun generateProperties(callableId: CallableId, context: MemberGenerationContext?): List - fun getCallableNamesForClass(classSymbol: FirClassSymbol<*>): Set - fun getNestedClassifiersNames(classSymbol: FirClassSymbol<*>): Set - fun getTopLevelCallableIds(): Set - fun getTopLevelClassIds(): Set - fun hasPackage(packageFqName: FqName): Boolean - - class Builder(override val session: FirSession) : Generation, FrontendPlugin.Builder() { - var classLikeDeclaration: (ClassId) -> FirClassLikeSymbol<*>? = { null } - var constructors: (MemberGenerationContext) -> List = { emptyList() } - var functions: (CallableId, MemberGenerationContext?) -> List = - { _, _ -> emptyList() } - var properties: (CallableId, MemberGenerationContext?) -> List = { _, _ -> emptyList() } - var callableNamesForClass: (FirClassSymbol<*>) -> Set = { emptySet() } - var nestedClassifiersNames: (FirClassSymbol<*>) -> Set = { emptySet() } - var topLevelCallableIds: () -> Set = { emptySet() } - var topLevelClassIds: () -> Set = { emptySet() } - var containsPackage: (FqName) -> Boolean = { false } - override fun generateClassLikeDeclaration(classId: ClassId): FirClassLikeSymbol<*>? { - return classLikeDeclaration(classId) - } - - override fun generateConstructors(context: MemberGenerationContext): List { - return constructors(context) - } - - override fun generateFunctions( - callableId: CallableId, - context: MemberGenerationContext? - ): List { - return functions(callableId, context) - } - - override fun generateProperties( - callableId: CallableId, - context: MemberGenerationContext? - ): List { - return properties(callableId, context) - } - - override fun getCallableNamesForClass(classSymbol: FirClassSymbol<*>): Set { - return callableNamesForClass(classSymbol) - } - - override fun getNestedClassifiersNames(classSymbol: FirClassSymbol<*>): Set { - return nestedClassifiersNames(classSymbol) - } - - override fun getTopLevelCallableIds(): Set { - return topLevelCallableIds() - } - - override fun getTopLevelClassIds(): Set { - return topLevelClassIds() - } - - override fun hasPackage(packageFqName: FqName): Boolean { - return containsPackage(packageFqName) - } - } - - companion object { - operator fun invoke(init: Builder.() -> Unit): (FirSession) -> Generation = - { Builder(it).apply(init) } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/MetaFirTransformer.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/MetaFirTransformer.kt deleted file mode 100644 index 598206f..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/MetaFirTransformer.kt +++ /dev/null @@ -1,745 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.fir.* -import org.jetbrains.kotlin.fir.contracts.* -import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder -import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.references.* -import org.jetbrains.kotlin.fir.types.* -import org.jetbrains.kotlin.fir.visitors.FirTransformer - -class MetaFirTransformer(val builder: Transformer) : FirTransformer() { - override fun transformElement(element: E, data: FirElement): E { - element.transformChildren(this, data) - return element - } - - override fun transformAnnotation(annotation: FirAnnotation, data: FirElement): FirStatement { - return builder.transformAnnotation(annotation, data) - } - - override fun transformAnnotationArgumentMapping( - annotationArgumentMapping: FirAnnotationArgumentMapping, - data: FirElement - ): FirAnnotationArgumentMapping { - return builder.transformAnnotationArgumentMapping(annotationArgumentMapping, data) - } - - override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: FirElement): FirStatement { - return builder.transformAnnotationCall(annotationCall, data) - } - - override fun transformAnnotationContainer( - annotationContainer: FirAnnotationContainer, - data: FirElement - ): FirAnnotationContainer { - return builder.transformAnnotationContainer(annotationContainer, data) - } - - override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: FirElement): FirStatement { - return builder.transformAnonymousFunction(anonymousFunction, data) - } - - override fun transformAnonymousFunctionExpression( - anonymousFunctionExpression: FirAnonymousFunctionExpression, - data: FirElement - ): FirStatement { - return builder.transformAnonymousFunctionExpression(anonymousFunctionExpression, data) - } - - override fun transformAnonymousInitializer( - anonymousInitializer: FirAnonymousInitializer, - data: FirElement - ): FirAnonymousInitializer { - return builder.transformAnonymousInitializer(anonymousInitializer, data) - } - - override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: FirElement): FirStatement { - return builder.transformAnonymousObject(anonymousObject, data) - } - - override fun transformAnonymousObjectExpression( - anonymousObjectExpression: FirAnonymousObjectExpression, - data: FirElement - ): FirStatement { - return builder.transformAnonymousObjectExpression(anonymousObjectExpression, data) - } - - override fun transformArgumentList(argumentList: FirArgumentList, data: FirElement): FirArgumentList { - return builder.transformArgumentList(argumentList, data) - } - - override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: FirElement): FirStatement { - return builder.transformArrayOfCall(arrayOfCall, data) - } - - override fun transformAssignmentOperatorStatement( - assignmentOperatorStatement: FirAssignmentOperatorStatement, - data: FirElement - ): FirStatement { - return builder.transformAssignmentOperatorStatement(assignmentOperatorStatement, data) - } - - override fun transformAugmentedArraySetCall( - augmentedArraySetCall: FirAugmentedArraySetCall, - data: FirElement - ): FirStatement { - return builder.transformAugmentedArraySetCall(augmentedArraySetCall, data) - } - - override fun transformBackingField(backingField: FirBackingField, data: FirElement): FirStatement { - return builder.transformBackingField(backingField, data) - } - - override fun transformBackingFieldReference( - backingFieldReference: FirBackingFieldReference, - data: FirElement - ): FirReference { - return builder.transformBackingFieldReference(backingFieldReference, data) - } - - override fun transformBinaryLogicExpression( - binaryLogicExpression: FirBinaryLogicExpression, - data: FirElement - ): FirStatement { - return builder.transformBinaryLogicExpression(binaryLogicExpression, data) - } - - override fun transformBlock(block: FirBlock, data: FirElement): FirStatement { - return builder.transformBlock(block, data) - } - - override fun transformBreakExpression(breakExpression: FirBreakExpression, data: FirElement): FirStatement { - return builder.transformBreakExpression(breakExpression, data) - } - - override fun transformCall(call: FirCall, data: FirElement): FirStatement { - return builder.transformCall(call, data) - } - - override fun transformCallableDeclaration( - callableDeclaration: FirCallableDeclaration, - data: FirElement - ): FirCallableDeclaration { - return builder.transformCallableDeclaration(callableDeclaration, data) - } - - override fun transformCallableReferenceAccess( - callableReferenceAccess: FirCallableReferenceAccess, - data: FirElement - ): FirStatement { - return builder.transformCallableReferenceAccess(callableReferenceAccess, data) - } - - override fun transformCatch(catch: FirCatch, data: FirElement): FirCatch { - return builder.transformCatch(catch, data) - } - - override fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: FirElement): FirStatement { - return builder.transformCheckNotNullCall(checkNotNullCall, data) - } - - override fun transformCheckedSafeCallSubject( - checkedSafeCallSubject: FirCheckedSafeCallSubject, - data: FirElement - ): FirStatement { - return builder.transformCheckedSafeCallSubject(checkedSafeCallSubject, data) - } - - override fun transformClass(klass: FirClass, data: FirElement): FirStatement { - return builder.transformClass(klass, data) - } - - override fun transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: FirElement): FirStatement { - return builder.transformClassLikeDeclaration(classLikeDeclaration, data) - } - - override fun transformClassReferenceExpression( - classReferenceExpression: FirClassReferenceExpression, - data: FirElement - ): FirStatement { - return builder.transformClassReferenceExpression(classReferenceExpression, data) - } - - override fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, data: FirElement): FirStatement { - return builder.transformComparisonExpression(comparisonExpression, data) - } - - override fun transformComponentCall(componentCall: FirComponentCall, data: FirElement): FirStatement { - return builder.transformComponentCall(componentCall, data) - } - - override fun transformConstExpression(constExpression: FirConstExpression, data: FirElement): FirStatement { - return builder.transformConstExpression(constExpression, data) - } - - override fun transformConstructor(constructor: FirConstructor, data: FirElement): FirStatement { - return builder.transformConstructor(constructor, data) - } - - override fun transformContextReceiver(contextReceiver: FirContextReceiver, data: FirElement): FirContextReceiver { - return builder.transformContextReceiver(contextReceiver, data) - } - - override fun transformContextReceiverArgumentListOwner( - contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, - data: FirElement - ): FirContextReceiverArgumentListOwner { - return builder.transformContextReceiverArgumentListOwner(contextReceiverArgumentListOwner, data) - } - - override fun transformContinueExpression(continueExpression: FirContinueExpression, data: FirElement): FirStatement { - return builder.transformContinueExpression(continueExpression, data) - } - - override fun transformContractDescription( - contractDescription: FirContractDescription, - data: FirElement - ): FirContractDescription { - return builder.transformContractDescription(contractDescription, data) - } - - override fun transformContractDescriptionOwner( - contractDescriptionOwner: FirContractDescriptionOwner, - data: FirElement - ): FirContractDescriptionOwner { - return builder.transformContractDescriptionOwner(contractDescriptionOwner, data) - } - - override fun transformControlFlowGraphOwner( - controlFlowGraphOwner: FirControlFlowGraphOwner, - data: FirElement - ): FirControlFlowGraphOwner { - return builder.transformControlFlowGraphOwner(controlFlowGraphOwner, data) - } - - override fun transformControlFlowGraphReference( - controlFlowGraphReference: FirControlFlowGraphReference, - data: FirElement - ): FirReference { - return builder.transformControlFlowGraphReference(controlFlowGraphReference, data) - } - - override fun transformDanglingModifierList( - danglingModifierList: FirDanglingModifierList, - data: FirElement - ): FirDanglingModifierList { - return builder.transformDanglingModifierList(danglingModifierList, data) - } - - override fun transformDeclaration(declaration: FirDeclaration, data: FirElement): FirDeclaration { - return builder.transformDeclaration(declaration, data) - } - - override fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: FirElement): FirDeclarationStatus { - return builder.transformDeclarationStatus(declarationStatus, data) - } - - override fun transformDelegateFieldReference( - delegateFieldReference: FirDelegateFieldReference, - data: FirElement - ): FirReference { - return builder.transformDelegateFieldReference(delegateFieldReference, data) - } - - override fun transformDelegatedConstructorCall( - delegatedConstructorCall: FirDelegatedConstructorCall, - data: FirElement - ): FirStatement { - return builder.transformDelegatedConstructorCall(delegatedConstructorCall, data) - } - - override fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: FirElement): FirDiagnosticHolder { - return builder.transformDiagnosticHolder(diagnosticHolder, data) - } - - override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: FirElement): FirStatement { - return builder.transformDoWhileLoop(doWhileLoop, data) - } - - override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: FirElement): FirTypeRef { - return builder.transformDynamicTypeRef(dynamicTypeRef, data) - } - - override fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: FirElement): FirEffectDeclaration { - return builder.transformEffectDeclaration(effectDeclaration, data) - } - - override fun transformElementWithResolvePhase( - elementWithResolvePhase: FirElementWithResolvePhase, - data: FirElement - ): FirElementWithResolvePhase { - return builder.transformElementWithResolvePhase(elementWithResolvePhase, data) - } - - override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: FirElement): FirStatement { - return builder.transformElvisExpression(elvisExpression, data) - } - - override fun transformEnumEntry(enumEntry: FirEnumEntry, data: FirElement): FirStatement { - return builder.transformEnumEntry(enumEntry, data) - } - - override fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: FirElement): FirStatement { - return builder.transformEqualityOperatorCall(equalityOperatorCall, data) - } - - override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: FirElement): FirStatement { - return builder.transformErrorAnnotationCall(errorAnnotationCall, data) - } - - override fun transformErrorExpression(errorExpression: FirErrorExpression, data: FirElement): FirStatement { - return builder.transformErrorExpression(errorExpression, data) - } - - override fun transformErrorFunction(errorFunction: FirErrorFunction, data: FirElement): FirStatement { - return builder.transformErrorFunction(errorFunction, data) - } - - override fun transformErrorImport(errorImport: FirErrorImport, data: FirElement): FirImport { - return builder.transformErrorImport(errorImport, data) - } - - override fun transformErrorLoop(errorLoop: FirErrorLoop, data: FirElement): FirStatement { - return builder.transformErrorLoop(errorLoop, data) - } - - override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: FirElement): FirReference { - return builder.transformErrorNamedReference(errorNamedReference, data) - } - - override fun transformErrorProperty(errorProperty: FirErrorProperty, data: FirElement): FirStatement { - return builder.transformErrorProperty(errorProperty, data) - } - - override fun transformErrorResolvedQualifier( - errorResolvedQualifier: FirErrorResolvedQualifier, - data: FirElement - ): FirStatement { - return builder.transformErrorResolvedQualifier(errorResolvedQualifier, data) - } - - override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: FirElement): FirTypeRef { - return builder.transformErrorTypeRef(errorTypeRef, data) - } - - override fun transformExpression(expression: FirExpression, data: FirElement): FirStatement { - return builder.transformExpression(expression, data) - } - - override fun transformField(field: FirField, data: FirElement): FirStatement { - return builder.transformField(field, data) - } - - override fun transformFile(file: FirFile, data: FirElement): FirFile { - return builder.transformFile(file, data) - } - - override fun transformFileAnnotationsContainer( - fileAnnotationsContainer: FirFileAnnotationsContainer, - data: FirElement - ): FirFileAnnotationsContainer { - return builder.transformFileAnnotationsContainer(fileAnnotationsContainer, data) - } - - override fun transformFunction(function: FirFunction, data: FirElement): FirStatement { - return builder.transformFunction(function, data) - } - - override fun transformFunctionCall(functionCall: FirFunctionCall, data: FirElement): FirStatement { - return builder.transformFunctionCall(functionCall, data) - } - - override fun transformFunctionTypeParameter( - functionTypeParameter: FirFunctionTypeParameter, - data: FirElement - ): FirFunctionTypeParameter { - return builder.transformFunctionTypeParameter(functionTypeParameter, data) - } - - override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: FirElement): FirTypeRef { - return builder.transformFunctionTypeRef(functionTypeRef, data) - } - - override fun transformGetClassCall(getClassCall: FirGetClassCall, data: FirElement): FirStatement { - return builder.transformGetClassCall(getClassCall, data) - } - - override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: FirElement): FirStatement { - return builder.transformImplicitInvokeCall(implicitInvokeCall, data) - } - - override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: FirElement): FirTypeRef { - return builder.transformImplicitTypeRef(implicitTypeRef, data) - } - - override fun transformImport(import: FirImport, data: FirElement): FirImport { - return builder.transformImport(import, data) - } - - override fun transformIntegerLiteralOperatorCall( - integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, - data: FirElement - ): FirStatement { - return builder.transformIntegerLiteralOperatorCall(integerLiteralOperatorCall, data) - } - - override fun transformIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, data: FirElement): FirTypeRef { - return builder.transformIntersectionTypeRef(intersectionTypeRef, data) - } - - override fun transformJump(jump: FirJump, data: FirElement): FirStatement { - return builder.transformJump(jump, data) - } - - override fun transformLabel(label: FirLabel, data: FirElement): FirLabel { - return builder.transformLabel(label, data) - } - - override fun transformLambdaArgumentExpression( - lambdaArgumentExpression: FirLambdaArgumentExpression, - data: FirElement - ): FirStatement { - return builder.transformLambdaArgumentExpression(lambdaArgumentExpression, data) - } - - override fun transformLegacyRawContractDescription( - legacyRawContractDescription: FirLegacyRawContractDescription, - data: FirElement - ): FirContractDescription { - return builder.transformLegacyRawContractDescription(legacyRawContractDescription, data) - } - - override fun transformLoop(loop: FirLoop, data: FirElement): FirStatement { - return builder.transformLoop(loop, data) - } - - override fun transformLoopJump(loopJump: FirLoopJump, data: FirElement): FirStatement { - return builder.transformLoopJump(loopJump, data) - } - - override fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: FirElement): FirMemberDeclaration { - return builder.transformMemberDeclaration(memberDeclaration, data) - } - - override fun transformNamedArgumentExpression( - namedArgumentExpression: FirNamedArgumentExpression, - data: FirElement - ): FirStatement { - return builder.transformNamedArgumentExpression(namedArgumentExpression, data) - } - - override fun transformNamedReference(namedReference: FirNamedReference, data: FirElement): FirReference { - return builder.transformNamedReference(namedReference, data) - } - - override fun transformNamedReferenceWithCandidateBase( - namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, - data: FirElement - ): FirReference { - return builder.transformNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase, data) - } - - override fun transformPackageDirective(packageDirective: FirPackageDirective, data: FirElement): FirPackageDirective { - return builder.transformPackageDirective(packageDirective, data) - } - - override fun transformPlaceholderProjection( - placeholderProjection: FirPlaceholderProjection, - data: FirElement - ): FirTypeProjection { - return builder.transformPlaceholderProjection(placeholderProjection, data) - } - - override fun transformProperty(property: FirProperty, data: FirElement): FirStatement { - return builder.transformProperty(property, data) - } - - override fun transformPropertyAccessExpression( - propertyAccessExpression: FirPropertyAccessExpression, - data: FirElement - ): FirStatement { - return builder.transformPropertyAccessExpression(propertyAccessExpression, data) - } - - override fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: FirElement): FirStatement { - return builder.transformPropertyAccessor(propertyAccessor, data) - } - - override fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: FirElement): FirStatement { - return builder.transformQualifiedAccess(qualifiedAccess, data) - } - - override fun transformQualifiedAccessExpression( - qualifiedAccessExpression: FirQualifiedAccessExpression, - data: FirElement - ): FirStatement { - return builder.transformQualifiedAccessExpression(qualifiedAccessExpression, data) - } - - override fun transformQualifiedErrorAccessExpression( - qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, - data: FirElement - ): FirStatement { - return builder.transformQualifiedErrorAccessExpression(qualifiedErrorAccessExpression, data) - } - - override fun transformRawContractDescription( - rawContractDescription: FirRawContractDescription, - data: FirElement - ): FirContractDescription { - return builder.transformRawContractDescription(rawContractDescription, data) - } - - override fun transformReceiverParameter(receiverParameter: FirReceiverParameter, data: FirElement): FirReceiverParameter { - return builder.transformReceiverParameter(receiverParameter, data) - } - - override fun transformReference(reference: FirReference, data: FirElement): FirReference { - return builder.transformReference(reference, data) - } - - override fun transformRegularClass(regularClass: FirRegularClass, data: FirElement): FirStatement { - return builder.transformRegularClass(regularClass, data) - } - - override fun transformResolvable(resolvable: FirResolvable, data: FirElement): FirResolvable { - return builder.transformResolvable(resolvable, data) - } - - override fun transformResolvedCallableReference( - resolvedCallableReference: FirResolvedCallableReference, - data: FirElement - ): FirReference { - return builder.transformResolvedCallableReference(resolvedCallableReference, data) - } - - override fun transformResolvedContractDescription( - resolvedContractDescription: FirResolvedContractDescription, - data: FirElement - ): FirContractDescription { - return builder.transformResolvedContractDescription(resolvedContractDescription, data) - } - - override fun transformResolvedDeclarationStatus( - resolvedDeclarationStatus: FirResolvedDeclarationStatus, - data: FirElement - ): FirDeclarationStatus { - return builder.transformResolvedDeclarationStatus(resolvedDeclarationStatus, data) - } - - override fun transformResolvedErrorReference( - resolvedErrorReference: FirResolvedErrorReference, - data: FirElement - ): FirReference { - return builder.transformResolvedErrorReference(resolvedErrorReference, data) - } - - override fun transformResolvedImport(resolvedImport: FirResolvedImport, data: FirElement): FirImport { - return builder.transformResolvedImport(resolvedImport, data) - } - - override fun transformResolvedNamedReference( - resolvedNamedReference: FirResolvedNamedReference, - data: FirElement - ): FirReference { - return builder.transformResolvedNamedReference(resolvedNamedReference, data) - } - - override fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: FirElement): FirStatement { - return builder.transformResolvedQualifier(resolvedQualifier, data) - } - - override fun transformResolvedReifiedParameterReference( - resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, - data: FirElement - ): FirStatement { - return builder.transformResolvedReifiedParameterReference(resolvedReifiedParameterReference, data) - } - - override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: FirElement): FirTypeRef { - return builder.transformResolvedTypeRef(resolvedTypeRef, data) - } - - override fun transformReturnExpression(returnExpression: FirReturnExpression, data: FirElement): FirStatement { - return builder.transformReturnExpression(returnExpression, data) - } - - override fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: FirElement): FirStatement { - return builder.transformSafeCallExpression(safeCallExpression, data) - } - - override fun transformScript(script: FirScript, data: FirElement): FirScript { - return builder.transformScript(script, data) - } - - override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: FirElement): FirStatement { - return builder.transformSimpleFunction(simpleFunction, data) - } - - override fun transformSmartCastExpression(smartCastExpression: FirSmartCastExpression, data: FirElement): FirStatement { - return builder.transformSmartCastExpression(smartCastExpression, data) - } - - override fun transformSpreadArgumentExpression( - spreadArgumentExpression: FirSpreadArgumentExpression, - data: FirElement - ): FirStatement { - return builder.transformSpreadArgumentExpression(spreadArgumentExpression, data) - } - - override fun transformStarProjection(starProjection: FirStarProjection, data: FirElement): FirTypeProjection { - return builder.transformStarProjection(starProjection, data) - } - - override fun transformStatement(statement: FirStatement, data: FirElement): FirStatement { - return builder.transformStatement(statement, data) - } - - override fun transformStringConcatenationCall( - stringConcatenationCall: FirStringConcatenationCall, - data: FirElement - ): FirStatement { - return builder.transformStringConcatenationCall(stringConcatenationCall, data) - } - - override fun transformSuperReference(superReference: FirSuperReference, data: FirElement): FirReference { - return builder.transformSuperReference(superReference, data) - } - - override fun transformTargetElement(targetElement: FirTargetElement, data: FirElement): FirTargetElement { - return builder.transformTargetElement(targetElement, data) - } - - override fun transformThisReceiverExpression( - thisReceiverExpression: FirThisReceiverExpression, - data: FirElement - ): FirStatement { - return builder.transformThisReceiverExpression(thisReceiverExpression, data) - } - - override fun transformThisReference(thisReference: FirThisReference, data: FirElement): FirReference { - return builder.transformThisReference(thisReference, data) - } - - override fun transformThrowExpression(throwExpression: FirThrowExpression, data: FirElement): FirStatement { - return builder.transformThrowExpression(throwExpression, data) - } - - override fun transformTryExpression(tryExpression: FirTryExpression, data: FirElement): FirStatement { - return builder.transformTryExpression(tryExpression, data) - } - - override fun transformTypeAlias(typeAlias: FirTypeAlias, data: FirElement): FirStatement { - return builder.transformTypeAlias(typeAlias, data) - } - - override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: FirElement): FirStatement { - return builder.transformTypeOperatorCall(typeOperatorCall, data) - } - - override fun transformTypeParameter(typeParameter: FirTypeParameter, data: FirElement): FirTypeParameterRef { - return builder.transformTypeParameter(typeParameter, data) - } - - override fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: FirElement): FirTypeParameterRef { - return builder.transformTypeParameterRef(typeParameterRef, data) - } - - override fun transformTypeParameterRefsOwner( - typeParameterRefsOwner: FirTypeParameterRefsOwner, - data: FirElement - ): FirTypeParameterRefsOwner { - return builder.transformTypeParameterRefsOwner(typeParameterRefsOwner, data) - } - - override fun transformTypeParametersOwner( - typeParametersOwner: FirTypeParametersOwner, - data: FirElement - ): FirTypeParametersOwner { - return builder.transformTypeParametersOwner(typeParametersOwner, data) - } - - override fun transformTypeProjection(typeProjection: FirTypeProjection, data: FirElement): FirTypeProjection { - return builder.transformTypeProjection(typeProjection, data) - } - - override fun transformTypeProjectionWithVariance( - typeProjectionWithVariance: FirTypeProjectionWithVariance, - data: FirElement - ): FirTypeProjection { - return builder.transformTypeProjectionWithVariance(typeProjectionWithVariance, data) - } - - override fun transformTypeRef(typeRef: FirTypeRef, data: FirElement): FirTypeRef { - return builder.transformTypeRef(typeRef, data) - } - - override fun transformTypeRefWithNullability( - typeRefWithNullability: FirTypeRefWithNullability, - data: FirElement - ): FirTypeRef { - return builder.transformTypeRefWithNullability(typeRefWithNullability, data) - } - - override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, data: FirElement): FirTypeRef { - return builder.transformUserTypeRef(userTypeRef, data) - } - - override fun transformValueParameter(valueParameter: FirValueParameter, data: FirElement): FirStatement { - return builder.transformValueParameter(valueParameter, data) - } - - override fun transformVarargArgumentsExpression( - varargArgumentsExpression: FirVarargArgumentsExpression, - data: FirElement - ): FirStatement { - return builder.transformVarargArgumentsExpression(varargArgumentsExpression, data) - } - - override fun transformVariable(variable: FirVariable, data: FirElement): FirStatement { - return builder.transformVariable(variable, data) - } - - override fun transformVariableAssignment(variableAssignment: FirVariableAssignment, data: FirElement): FirStatement { - return builder.transformVariableAssignment(variableAssignment, data) - } - - override fun transformWhenBranch(whenBranch: FirWhenBranch, data: FirElement): FirWhenBranch { - return builder.transformWhenBranch(whenBranch, data) - } - - override fun transformWhenExpression(whenExpression: FirWhenExpression, data: FirElement): FirStatement { - return builder.transformWhenExpression(whenExpression, data) - } - - override fun transformWhenSubjectExpression( - whenSubjectExpression: FirWhenSubjectExpression, - data: FirElement - ): FirStatement { - return builder.transformWhenSubjectExpression(whenSubjectExpression, data) - } - - override fun transformWhileLoop(whileLoop: FirWhileLoop, data: FirElement): FirStatement { - return builder.transformWhileLoop(whileLoop, data) - } - - override fun transformWrappedArgumentExpression( - wrappedArgumentExpression: FirWrappedArgumentExpression, - data: FirElement - ): FirStatement { - return builder.transformWrappedArgumentExpression(wrappedArgumentExpression, data) - } - - override fun transformWrappedDelegateExpression( - wrappedDelegateExpression: FirWrappedDelegateExpression, - data: FirElement - ): FirStatement { - return builder.transformWrappedDelegateExpression(wrappedDelegateExpression, data) - } - - override fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, data: FirElement): FirStatement { - return builder.transformWrappedExpression(wrappedExpression, data) - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/SAMConversionTransformer.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/SAMConversionTransformer.kt deleted file mode 100644 index c3757e9..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/SAMConversionTransformer.kt +++ /dev/null @@ -1,20 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction -import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType - -interface SAMConversionTransformer : FrontendPlugin { - fun getCustomFunctionalTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? - class Builder(override val session: FirSession) : SAMConversionTransformer, FrontendPlugin.Builder() { - - var getCustomFunctionalTypeForSamConversion: (FirSimpleFunction) -> ConeLookupTagBasedType? = { null } - - override fun getCustomFunctionalTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? = - this.getCustomFunctionalTypeForSamConversion(function) - } - - companion object { - operator fun invoke(init: Builder.() -> Unit): (FirSession) -> SAMConversionTransformer = { Builder(it).apply(init) } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ScriptConfigurator.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ScriptConfigurator.kt deleted file mode 100644 index 60c8660..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/ScriptConfigurator.kt +++ /dev/null @@ -1,20 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.builder.FirFileBuilder -import org.jetbrains.kotlin.fir.declarations.builder.FirScriptBuilder - -interface ScriptConfigurator : FrontendPlugin { - fun FirScriptBuilder.configure(fileBuilder: FirFileBuilder) - class Builder(override val session: FirSession) : ScriptConfigurator, FrontendPlugin.Builder() { - var configureScript: FirScriptBuilder.(FirFileBuilder) -> Unit = {} - - override fun FirScriptBuilder.configure(fileBuilder: FirFileBuilder) { - configureScript(fileBuilder) - } - } - - companion object { - operator fun invoke(init: Builder.() -> Unit): (FirSession) -> ScriptConfigurator = { Builder(it).apply(init) } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/StatusTransformer.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/StatusTransformer.kt deleted file mode 100644 index 7634924..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/StatusTransformer.kt +++ /dev/null @@ -1,24 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirDeclaration -import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus - -interface StatusTransformer : FrontendPlugin { - abstract fun needTransformStatus(declaration: FirDeclaration): Boolean - - fun transformStatus(status: FirDeclarationStatus, declaration: FirDeclaration): FirDeclarationStatus = status - - class Builder(override val session: FirSession) : StatusTransformer, FrontendPlugin.Builder() { - var shouldTransformStatus: (FirDeclaration) -> Boolean = { false } - var transformStatus: (FirDeclarationStatus) -> FirDeclarationStatus = { it } - - override fun needTransformStatus(declaration: FirDeclaration): Boolean { - return shouldTransformStatus(declaration) - } - } - - companion object { - operator fun invoke(init: Builder.() -> Unit): (FirSession) -> StatusTransformer = { Builder(it).apply(init) } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Supertypes.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Supertypes.kt deleted file mode 100644 index a932598..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Supertypes.kt +++ /dev/null @@ -1,32 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration -import org.jetbrains.kotlin.fir.extensions.FirSupertypeGenerationExtension -import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef - -interface Supertypes : FrontendPlugin { - context(FirSupertypeGenerationExtension.TypeResolveServiceContainer) fun computeAdditionalSupertypes( - classLikeDeclaration: FirClassLikeDeclaration, resolvedSupertypes: List - ): List - - fun needTransformSupertypes(declaration: FirClassLikeDeclaration): Boolean - - class Builder(override val session: FirSession) : Supertypes, FrontendPlugin.Builder() { - var additionalSupertypes: (FirClassLikeDeclaration, List) -> List = - { _, _ -> emptyList() } - var shouldTransformSupertypes: (FirClassLikeDeclaration) -> Boolean = { false } - override fun computeAdditionalSupertypes( - classLikeDeclaration: FirClassLikeDeclaration, - resolvedSupertypes: List - ): List = - additionalSupertypes(classLikeDeclaration, resolvedSupertypes) - - override fun needTransformSupertypes(declaration: FirClassLikeDeclaration): Boolean = - shouldTransformSupertypes(declaration) - } - - companion object { - operator fun invoke(init: Builder.() -> Unit): (FirSession) -> Supertypes = { Builder(it).apply(init) } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Transformer.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Transformer.kt deleted file mode 100644 index cee12e2..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/Transformer.kt +++ /dev/null @@ -1,1192 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.fir.* -import org.jetbrains.kotlin.fir.contracts.* -import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder -import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.references.* -import org.jetbrains.kotlin.fir.types.* - -interface Transformer : FrontendPlugin { - - fun transformAnnotationContainer(annotationContainer: FirAnnotationContainer, parent: FirElement): FirAnnotationContainer - - fun transformTypeRef(typeRef: FirTypeRef, parent: FirElement): FirTypeRef - - fun transformReference(reference: FirReference, parent: FirElement): FirReference - - fun transformLabel(label: FirLabel, parent: FirElement): FirLabel - - fun transformResolvable(resolvable: FirResolvable, parent: FirElement): FirResolvable - - fun transformTargetElement(targetElement: FirTargetElement, parent: FirElement): FirTargetElement - - fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, parent: FirElement): FirDeclarationStatus - - fun transformResolvedDeclarationStatus( - resolvedDeclarationStatus: FirResolvedDeclarationStatus, - parent: FirElement - ): FirDeclarationStatus - - fun transformControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, parent: FirElement): FirControlFlowGraphOwner - - fun transformStatement(statement: FirStatement, parent: FirElement): FirStatement - - fun transformExpression(expression: FirExpression, parent: FirElement): FirStatement - - fun transformContextReceiver(contextReceiver: FirContextReceiver, parent: FirElement): FirContextReceiver - - fun transformElementWithResolvePhase( - elementWithResolvePhase: FirElementWithResolvePhase, - parent: FirElement - ): FirElementWithResolvePhase - - fun transformFileAnnotationsContainer( - fileAnnotationsContainer: FirFileAnnotationsContainer, - parent: FirElement - ): FirFileAnnotationsContainer - - fun transformDeclaration(declaration: FirDeclaration, parent: FirElement): FirDeclaration - - fun transformTypeParameterRefsOwner( - typeParameterRefsOwner: FirTypeParameterRefsOwner, - parent: FirElement - ): FirTypeParameterRefsOwner - - fun transformTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, parent: FirElement): FirTypeParametersOwner - - fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, parent: FirElement): FirMemberDeclaration - - fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, parent: FirElement): FirAnonymousInitializer - - fun transformCallableDeclaration(callableDeclaration: FirCallableDeclaration, parent: FirElement): FirCallableDeclaration - - fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, parent: FirElement): FirTypeParameterRef - - fun transformTypeParameter(typeParameter: FirTypeParameter, parent: FirElement): FirTypeParameterRef - - fun transformVariable(variable: FirVariable, parent: FirElement): FirStatement - - fun transformValueParameter(valueParameter: FirValueParameter, parent: FirElement): FirStatement - - fun transformReceiverParameter(receiverParameter: FirReceiverParameter, parent: FirElement): FirReceiverParameter - - fun transformProperty(property: FirProperty, parent: FirElement): FirStatement - - fun transformField(field: FirField, parent: FirElement): FirStatement - - fun transformEnumEntry(enumEntry: FirEnumEntry, parent: FirElement): FirStatement - - fun transformFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter, parent: FirElement): FirFunctionTypeParameter - - fun transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, parent: FirElement): FirStatement - - fun transformClass(klass: FirClass, parent: FirElement): FirStatement - - fun transformRegularClass(regularClass: FirRegularClass, parent: FirElement): FirStatement - - fun transformTypeAlias(typeAlias: FirTypeAlias, parent: FirElement): FirStatement - - fun transformFunction(function: FirFunction, parent: FirElement): FirStatement - - fun transformContractDescriptionOwner( - contractDescriptionOwner: FirContractDescriptionOwner, - parent: FirElement - ): FirContractDescriptionOwner - - fun transformSimpleFunction(simpleFunction: FirSimpleFunction, parent: FirElement): FirStatement - - fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, parent: FirElement): FirStatement - - fun transformBackingField(backingField: FirBackingField, parent: FirElement): FirStatement - - fun transformConstructor(constructor: FirConstructor, parent: FirElement): FirStatement - - fun transformFile(file: FirFile, parent: FirElement): FirFile - - fun transformScript(script: FirScript, parent: FirElement): FirScript - - fun transformPackageDirective(packageDirective: FirPackageDirective, parent: FirElement): FirPackageDirective - - fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, parent: FirElement): FirStatement - - fun transformAnonymousFunctionExpression( - anonymousFunctionExpression: FirAnonymousFunctionExpression, - parent: FirElement - ): FirStatement - - fun transformAnonymousObject(anonymousObject: FirAnonymousObject, parent: FirElement): FirStatement - - fun transformAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression, parent: FirElement): FirStatement - - fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, parent: FirElement): FirDiagnosticHolder - - fun transformImport(import: FirImport, parent: FirElement): FirImport - - fun transformResolvedImport(resolvedImport: FirResolvedImport, parent: FirElement): FirImport - - fun transformErrorImport(errorImport: FirErrorImport, parent: FirElement): FirImport - - fun transformLoop(loop: FirLoop, parent: FirElement): FirStatement - - fun transformErrorLoop(errorLoop: FirErrorLoop, parent: FirElement): FirStatement - - fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, parent: FirElement): FirStatement - - fun transformWhileLoop(whileLoop: FirWhileLoop, parent: FirElement): FirStatement - - fun transformBlock(block: FirBlock, parent: FirElement): FirStatement - - fun transformBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, parent: FirElement): FirStatement - - fun transformJump(jump: FirJump, parent: FirElement): FirStatement - - fun transformLoopJump(loopJump: FirLoopJump, parent: FirElement): FirStatement - - fun transformBreakExpression(breakExpression: FirBreakExpression, parent: FirElement): FirStatement - - fun transformContinueExpression(continueExpression: FirContinueExpression, parent: FirElement): FirStatement - - fun transformCatch(catch: FirCatch, parent: FirElement): FirCatch - - fun transformTryExpression(tryExpression: FirTryExpression, parent: FirElement): FirStatement - - fun transformConstExpression(constExpression: FirConstExpression, parent: FirElement): FirStatement - - fun transformTypeProjection(typeProjection: FirTypeProjection, parent: FirElement): FirTypeProjection - - fun transformStarProjection(starProjection: FirStarProjection, parent: FirElement): FirTypeProjection - - fun transformPlaceholderProjection(placeholderProjection: FirPlaceholderProjection, parent: FirElement): FirTypeProjection - - fun transformTypeProjectionWithVariance( - typeProjectionWithVariance: FirTypeProjectionWithVariance, - parent: FirElement - ): FirTypeProjection - - fun transformArgumentList(argumentList: FirArgumentList, parent: FirElement): FirArgumentList - - fun transformCall(call: FirCall, parent: FirElement): FirStatement - - fun transformAnnotation(annotation: FirAnnotation, parent: FirElement): FirStatement - - fun transformAnnotationCall(annotationCall: FirAnnotationCall, parent: FirElement): FirStatement - - fun transformAnnotationArgumentMapping( - annotationArgumentMapping: FirAnnotationArgumentMapping, - parent: FirElement - ): FirAnnotationArgumentMapping - - fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, parent: FirElement): FirStatement - - fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, parent: FirElement): FirStatement - - fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, parent: FirElement): FirStatement - - fun transformAssignmentOperatorStatement( - assignmentOperatorStatement: FirAssignmentOperatorStatement, - parent: FirElement - ): FirStatement - - fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, parent: FirElement): FirStatement - - fun transformWhenExpression(whenExpression: FirWhenExpression, parent: FirElement): FirStatement - - fun transformWhenBranch(whenBranch: FirWhenBranch, parent: FirElement): FirWhenBranch - - fun transformContextReceiverArgumentListOwner( - contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, - parent: FirElement - ): FirContextReceiverArgumentListOwner - - fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, parent: FirElement): FirStatement - - fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, parent: FirElement): FirStatement - - fun transformElvisExpression(elvisExpression: FirElvisExpression, parent: FirElement): FirStatement - - fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, parent: FirElement): FirStatement - - fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, parent: FirElement): FirStatement - - fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, parent: FirElement): FirStatement - - fun transformErrorExpression(errorExpression: FirErrorExpression, parent: FirElement): FirStatement - - fun transformErrorFunction(errorFunction: FirErrorFunction, parent: FirElement): FirStatement - - fun transformErrorProperty(errorProperty: FirErrorProperty, parent: FirElement): FirStatement - - fun transformDanglingModifierList(danglingModifierList: FirDanglingModifierList, parent: FirElement): FirDanglingModifierList - - fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, parent: FirElement): FirStatement - - fun transformQualifiedErrorAccessExpression( - qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, - parent: FirElement - ): FirStatement - - fun transformPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression, parent: FirElement): FirStatement - - fun transformFunctionCall(functionCall: FirFunctionCall, parent: FirElement): FirStatement - - fun transformIntegerLiteralOperatorCall( - integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, - parent: FirElement - ): FirStatement - - fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, parent: FirElement): FirStatement - - fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, parent: FirElement): FirStatement - - fun transformComponentCall(componentCall: FirComponentCall, parent: FirElement): FirStatement - - fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, parent: FirElement): FirStatement - - fun transformThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, parent: FirElement): FirStatement - - fun transformSmartCastExpression(smartCastExpression: FirSmartCastExpression, parent: FirElement): FirStatement - - fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, parent: FirElement): FirStatement - - fun transformCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, parent: FirElement): FirStatement - - fun transformGetClassCall(getClassCall: FirGetClassCall, parent: FirElement): FirStatement - - fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, parent: FirElement): FirStatement - - fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, parent: FirElement): FirStatement - - fun transformLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, parent: FirElement): FirStatement - - fun transformSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, parent: FirElement): FirStatement - - fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, parent: FirElement): FirStatement - - fun transformVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, parent: FirElement): FirStatement - - fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, parent: FirElement): FirStatement - - fun transformErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, parent: FirElement): FirStatement - - fun transformResolvedReifiedParameterReference( - resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, - parent: FirElement - ): FirStatement - - fun transformReturnExpression(returnExpression: FirReturnExpression, parent: FirElement): FirStatement - - fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, parent: FirElement): FirStatement - - fun transformThrowExpression(throwExpression: FirThrowExpression, parent: FirElement): FirStatement - - fun transformVariableAssignment(variableAssignment: FirVariableAssignment, parent: FirElement): FirStatement - - fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, parent: FirElement): FirStatement - - fun transformWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, parent: FirElement): FirStatement - - fun transformNamedReference(namedReference: FirNamedReference, parent: FirElement): FirReference - - fun transformNamedReferenceWithCandidateBase( - namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, - parent: FirElement - ): FirReference - - fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, parent: FirElement): FirReference - - fun transformSuperReference(superReference: FirSuperReference, parent: FirElement): FirReference - - fun transformThisReference(thisReference: FirThisReference, parent: FirElement): FirReference - - fun transformControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, parent: FirElement): FirReference - - fun transformResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, parent: FirElement): FirReference - - fun transformResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference, parent: FirElement): FirReference - - fun transformDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, parent: FirElement): FirReference - - fun transformBackingFieldReference(backingFieldReference: FirBackingFieldReference, parent: FirElement): FirReference - - fun transformResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, parent: FirElement): FirReference - - fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, parent: FirElement): FirTypeRef - - fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, parent: FirElement): FirTypeRef - - fun transformTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, parent: FirElement): FirTypeRef - - fun transformUserTypeRef(userTypeRef: FirUserTypeRef, parent: FirElement): FirTypeRef - - fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, parent: FirElement): FirTypeRef - - fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, parent: FirElement): FirTypeRef - - fun transformIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, parent: FirElement): FirTypeRef - - fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, parent: FirElement): FirTypeRef - - fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, parent: FirElement): FirEffectDeclaration - - fun transformContractDescription(contractDescription: FirContractDescription, parent: FirElement): FirContractDescription - - fun transformLegacyRawContractDescription( - legacyRawContractDescription: FirLegacyRawContractDescription, - parent: FirElement - ): FirContractDescription - - fun transformRawContractDescription( - rawContractDescription: FirRawContractDescription, - parent: FirElement - ): FirContractDescription - - fun transformResolvedContractDescription( - resolvedContractDescription: FirResolvedContractDescription, - parent: FirElement - ): FirContractDescription - - class Builder(override val session: FirSession) : Transformer, FrontendPlugin.Builder() { - var annotationContainer: (FirAnnotationContainer, parent: FirElement) -> FirAnnotationContainer = { el, _ -> el } - - override fun transformAnnotationContainer( - annotationContainer: FirAnnotationContainer, - parent: FirElement - ): FirAnnotationContainer = - annotationContainer(annotationContainer, parent) - - var typeRef: (typeRef: FirTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } - - override fun transformTypeRef(typeRef: FirTypeRef, parent: FirElement): FirTypeRef = - typeRef(typeRef, parent) - - var typeProjection: (typeProjection: FirTypeProjection, parent: FirElement) -> FirTypeProjection = { el, _ -> el } - - override fun transformTypeProjection(typeProjection: FirTypeProjection, parent: FirElement): FirTypeProjection = - typeProjection(typeProjection, parent) - - var typeProjectionWithVariance: (typeProjectionWithVariance: FirTypeProjectionWithVariance, parent: FirElement) -> FirTypeProjectionWithVariance = - { el, _ -> el } - - override fun transformTypeProjectionWithVariance( - typeProjectionWithVariance: FirTypeProjectionWithVariance, - parent: FirElement - ): FirTypeProjectionWithVariance = - typeProjectionWithVariance(typeProjectionWithVariance, parent) - - var starProjection: (starProjection: FirStarProjection, parent: FirElement) -> FirStarProjection = { el, _ -> el } - - override fun transformStarProjection(starProjection: FirStarProjection, parent: FirElement): FirStarProjection = - starProjection(starProjection, parent) - - var reference: (reference: FirReference, parent: FirElement) -> FirReference = { el, _ -> el } - override fun transformReference(reference: FirReference, parent: FirElement): FirReference = - reference(reference, parent) - - var label: (label: FirLabel, parent: FirElement) -> FirLabel = { el, _ -> el } - override fun transformLabel(label: FirLabel, parent: FirElement): FirLabel = - label(label, parent) - - var resolvable: (resolvable: FirResolvable, parent: FirElement) -> FirResolvable = { el, _ -> el } - override fun transformResolvable(resolvable: FirResolvable, parent: FirElement): FirResolvable = - resolvable(resolvable, parent) - - var targetElement: (targetElement: FirTargetElement, parent: FirElement) -> FirTargetElement = { el, _ -> el } - override fun transformTargetElement(targetElement: FirTargetElement, parent: FirElement): FirTargetElement = - targetElement(targetElement, parent) - - var declarationStatus: (declarationStatus: FirDeclarationStatus, parent: FirElement) -> FirDeclarationStatus = { el, _ -> el } - override fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, parent: FirElement): FirDeclarationStatus = - declarationStatus(declarationStatus, parent) - - var resolvedDeclarationStatus: (resolvedDeclarationStatus: FirResolvedDeclarationStatus, parent: FirElement) -> FirDeclarationStatus = - { el, _ -> el } - - override fun transformResolvedDeclarationStatus( - resolvedDeclarationStatus: FirResolvedDeclarationStatus, - parent: FirElement - ): FirDeclarationStatus = - resolvedDeclarationStatus(resolvedDeclarationStatus, parent) - - var controlFlowGraphOwner: (controlFlowGraphOwner: FirControlFlowGraphOwner, parent: FirElement) -> FirControlFlowGraphOwner = - { el, _ -> el } - - override fun transformControlFlowGraphOwner( - controlFlowGraphOwner: FirControlFlowGraphOwner, - parent: FirElement - ): FirControlFlowGraphOwner = - controlFlowGraphOwner(controlFlowGraphOwner, parent) - - var statement: (statement: FirStatement, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformStatement(statement: FirStatement, parent: FirElement): FirStatement = - statement(statement, parent) - - var expression: (expression: FirExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformExpression(expression: FirExpression, parent: FirElement): FirStatement = - expression(expression, parent) - - var contextReceiver: (contextReceiver: FirContextReceiver, parent: FirElement) -> FirContextReceiver = { el, _ -> el } - override fun transformContextReceiver(contextReceiver: FirContextReceiver, parent: FirElement): FirContextReceiver = - contextReceiver(contextReceiver, parent) - - var elementWithResolvePhase: (elementWithResolvePhase: FirElementWithResolvePhase, parent: FirElement) -> FirElementWithResolvePhase = - { el, _ -> el } - - override fun transformElementWithResolvePhase( - elementWithResolvePhase: FirElementWithResolvePhase, - parent: FirElement - ): FirElementWithResolvePhase = - elementWithResolvePhase(elementWithResolvePhase, parent) - - var fileAnnotationsContainer: (fileAnnotationsContainer: FirFileAnnotationsContainer, parent: FirElement) -> FirFileAnnotationsContainer = - { el, _ -> el } - - override fun transformFileAnnotationsContainer( - fileAnnotationsContainer: FirFileAnnotationsContainer, - parent: FirElement - ): FirFileAnnotationsContainer = - fileAnnotationsContainer(fileAnnotationsContainer, parent) - - var declaration: (declaration: FirDeclaration, parent: FirElement) -> FirDeclaration = { el, _ -> el } - override fun transformDeclaration(declaration: FirDeclaration, parent: FirElement): FirDeclaration = - declaration(declaration, parent) - - var typeParameterRefsOwner: (typeParameterRefsOwner: FirTypeParameterRefsOwner, parent: FirElement) -> FirTypeParameterRefsOwner = - { el, _ -> el } - - override fun transformTypeParameterRefsOwner( - typeParameterRefsOwner: FirTypeParameterRefsOwner, - parent: FirElement - ): FirTypeParameterRefsOwner = - typeParameterRefsOwner(typeParameterRefsOwner, parent) - - var typeParametersOwner: (typeParametersOwner: FirTypeParametersOwner, parent: FirElement) -> FirTypeParametersOwner = - { el, _ -> el } - - override fun transformTypeParametersOwner( - typeParametersOwner: FirTypeParametersOwner, - parent: FirElement - ): FirTypeParametersOwner = - typeParametersOwner(typeParametersOwner, parent) - - var memberDeclaration: (memberDeclaration: FirMemberDeclaration, parent: FirElement) -> FirMemberDeclaration = { el, _ -> el } - override fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, parent: FirElement): FirMemberDeclaration = - memberDeclaration(memberDeclaration, parent) - - var anonymousInitializer: (anonymousInitializer: FirAnonymousInitializer, parent: FirElement) -> FirAnonymousInitializer = - { el, _ -> el } - - override fun transformAnonymousInitializer( - anonymousInitializer: FirAnonymousInitializer, - parent: FirElement - ): FirAnonymousInitializer = - anonymousInitializer(anonymousInitializer, parent) - - var callableDeclaration: (callableDeclaration: FirCallableDeclaration, parent: FirElement) -> FirCallableDeclaration = - { el, _ -> el } - - override fun transformCallableDeclaration( - callableDeclaration: FirCallableDeclaration, - parent: FirElement - ): FirCallableDeclaration = - callableDeclaration(callableDeclaration, parent) - - var typeParameterRef: (typeParameterRef: FirTypeParameterRef, parent: FirElement) -> FirTypeParameterRef = { el, _ -> el } - override fun transformTypeParameterRef(typeParameterRef: FirTypeParameterRef, parent: FirElement): FirTypeParameterRef = - typeParameterRef(typeParameterRef, parent) - - var typeParameter: (typeParameter: FirTypeParameter, parent: FirElement) -> FirTypeParameterRef = { el, _ -> el } - override fun transformTypeParameter(typeParameter: FirTypeParameter, parent: FirElement): FirTypeParameterRef = - typeParameter(typeParameter, parent) - - var variable: (variable: FirVariable, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformVariable(variable: FirVariable, parent: FirElement): FirStatement = - variable(variable, parent) - - var valueParameter: (valueParameter: FirValueParameter, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformValueParameter(valueParameter: FirValueParameter, parent: FirElement): FirStatement = - valueParameter(valueParameter, parent) - - var receiverParameter: (receiverParameter: FirReceiverParameter, parent: FirElement) -> FirReceiverParameter = { el, _ -> el } - override fun transformReceiverParameter(receiverParameter: FirReceiverParameter, parent: FirElement): FirReceiverParameter = - receiverParameter(receiverParameter, parent) - - var property: (property: FirProperty, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformProperty(property: FirProperty, parent: FirElement): FirStatement = - property(property, parent) - - var field: (field: FirField, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformField(field: FirField, parent: FirElement): FirStatement = - field(field, parent) - - var enumEntry: (enumEntry: FirEnumEntry, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformEnumEntry(enumEntry: FirEnumEntry, parent: FirElement): FirStatement = - enumEntry(enumEntry, parent) - - var functionTypeParameter: (functionTypeParameter: FirFunctionTypeParameter, parent: FirElement) -> FirFunctionTypeParameter = - { el, _ -> el } - - override fun transformFunctionTypeParameter( - functionTypeParameter: FirFunctionTypeParameter, - parent: FirElement - ): FirFunctionTypeParameter = - functionTypeParameter(functionTypeParameter, parent) - - var classLikeDeclaration: (classLikeDeclaration: FirClassLikeDeclaration, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, parent: FirElement): FirStatement = - classLikeDeclaration(classLikeDeclaration, parent) - - var klass: (klass: FirClass, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformClass(klass: FirClass, parent: FirElement): FirStatement = - klass(klass, parent) - - var regularClass: (regularClass: FirRegularClass, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformRegularClass(regularClass: FirRegularClass, parent: FirElement): FirStatement = - regularClass(regularClass, parent) - - var typeAlias: (typeAlias: FirTypeAlias, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformTypeAlias(typeAlias: FirTypeAlias, parent: FirElement): FirStatement = - typeAlias(typeAlias, parent) - - var function: (function: FirFunction, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformFunction(function: FirFunction, parent: FirElement): FirStatement = - function(function, parent) - - var contractDescriptionOwner: (contractDescriptionOwner: FirContractDescriptionOwner, parent: FirElement) -> FirContractDescriptionOwner = - { el, _ -> el } - - override fun transformContractDescriptionOwner( - contractDescriptionOwner: FirContractDescriptionOwner, - parent: FirElement - ): FirContractDescriptionOwner = - contractDescriptionOwner(contractDescriptionOwner, parent) - - var simpleFunction: (simpleFunction: FirSimpleFunction, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, parent: FirElement): FirStatement = - simpleFunction(simpleFunction, parent) - - var propertyAccessor: (propertyAccessor: FirPropertyAccessor, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, parent: FirElement): FirStatement = - propertyAccessor(propertyAccessor, parent) - - var backingField: (backingField: FirBackingField, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformBackingField(backingField: FirBackingField, parent: FirElement): FirStatement = - backingField(backingField, parent) - - var constructor: (constructor: FirConstructor, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformConstructor(constructor: FirConstructor, parent: FirElement): FirStatement = - constructor(constructor, parent) - - var file: (file: FirFile, parent: FirElement) -> FirFile = { el, _ -> el } - override fun transformFile(file: FirFile, parent: FirElement): FirFile = - file(file, parent) - - var script: (script: FirScript, parent: FirElement) -> FirScript = { el, _ -> el } - override fun transformScript(script: FirScript, parent: FirElement): FirScript = - script(script, parent) - - var packageDirective: (packageDirective: FirPackageDirective, parent: FirElement) -> FirPackageDirective = { el, _ -> el } - override fun transformPackageDirective(packageDirective: FirPackageDirective, parent: FirElement): FirPackageDirective = - packageDirective(packageDirective, parent) - - var anonymousFunction: (anonymousFunction: FirAnonymousFunction, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, parent: FirElement): FirStatement = - anonymousFunction(anonymousFunction, parent) - - var anonymousFunctionExpression: (anonymousFunctionExpression: FirAnonymousFunctionExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformAnonymousFunctionExpression( - anonymousFunctionExpression: FirAnonymousFunctionExpression, - parent: FirElement - ): FirStatement = - anonymousFunctionExpression(anonymousFunctionExpression, parent) - - var anonymousObject: (anonymousObject: FirAnonymousObject, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, parent: FirElement): FirStatement = - anonymousObject(anonymousObject, parent) - - var anonymousObjectExpression: (anonymousObjectExpression: FirAnonymousObjectExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformAnonymousObjectExpression( - anonymousObjectExpression: FirAnonymousObjectExpression, - parent: FirElement - ): FirStatement = - anonymousObjectExpression(anonymousObjectExpression, parent) - - var diagnosticHolder: (diagnosticHolder: FirDiagnosticHolder, parent: FirElement) -> FirDiagnosticHolder = { el, _ -> el } - override fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, parent: FirElement): FirDiagnosticHolder = - diagnosticHolder(diagnosticHolder, parent) - - var import: (import: FirImport, parent: FirElement) -> FirImport = { el, _ -> el } - override fun transformImport(import: FirImport, parent: FirElement): FirImport = - import(import, parent) - - var resolvedImport: (resolvedImport: FirResolvedImport, parent: FirElement) -> FirImport = { el, _ -> el } - override fun transformResolvedImport(resolvedImport: FirResolvedImport, parent: FirElement): FirImport = - resolvedImport(resolvedImport, parent) - - var errorImport: (errorImport: FirErrorImport, parent: FirElement) -> FirImport = { el, _ -> el } - override fun transformErrorImport(errorImport: FirErrorImport, parent: FirElement): FirImport = - errorImport(errorImport, parent) - - var loop: (loop: FirLoop, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformLoop(loop: FirLoop, parent: FirElement): FirStatement = - loop(loop, parent) - - var errorLoop: (errorLoop: FirErrorLoop, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformErrorLoop(errorLoop: FirErrorLoop, parent: FirElement): FirStatement = - errorLoop(errorLoop, parent) - - var doWhileLoop: (doWhileLoop: FirDoWhileLoop, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, parent: FirElement): FirStatement = - doWhileLoop(doWhileLoop, parent) - - var whileLoop: (whileLoop: FirWhileLoop, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformWhileLoop(whileLoop: FirWhileLoop, parent: FirElement): FirStatement = - whileLoop(whileLoop, parent) - - var block: (block: FirBlock, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformBlock(block: FirBlock, parent: FirElement): FirStatement = - block(block, parent) - - var binaryLogicExpression: (binaryLogicExpression: FirBinaryLogicExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformBinaryLogicExpression( - binaryLogicExpression: FirBinaryLogicExpression, - parent: FirElement - ): FirStatement = - binaryLogicExpression(binaryLogicExpression, parent) - - var jump: (jump: FirJump<*>, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformJump(jump: FirJump, parent: FirElement): FirStatement = - jump(jump, parent) - - var loopJump: (loopJump: FirLoopJump, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformLoopJump(loopJump: FirLoopJump, parent: FirElement): FirStatement = - loopJump(loopJump, parent) - - var breakExpression: (breakExpression: FirBreakExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformBreakExpression(breakExpression: FirBreakExpression, parent: FirElement): FirStatement = - breakExpression(breakExpression, parent) - - var continueExpression: (continueExpression: FirContinueExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformContinueExpression(continueExpression: FirContinueExpression, parent: FirElement): FirStatement = - continueExpression(continueExpression, parent) - - var catch: (catch: FirCatch, parent: FirElement) -> FirCatch = { el, _ -> el } - override fun transformCatch(catch: FirCatch, parent: FirElement): FirCatch = - catch(catch, parent) - - var tryExpression: (tryExpression: FirTryExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformTryExpression(tryExpression: FirTryExpression, parent: FirElement): FirStatement = - tryExpression(tryExpression, parent) - - var constExpression: (constExpression: FirConstExpression<*>, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformConstExpression(constExpression: FirConstExpression, parent: FirElement): FirStatement = - constExpression(constExpression, parent) - - var placeholderProjection: (placeholderProjection: FirPlaceholderProjection, parent: FirElement) -> FirTypeProjection = - { el, _ -> el } - - override fun transformPlaceholderProjection( - placeholderProjection: FirPlaceholderProjection, - parent: FirElement - ): FirTypeProjection = - placeholderProjection(placeholderProjection, parent) - - var argumentList: (argumentList: FirArgumentList, parent: FirElement) -> FirArgumentList = { el, _ -> el } - override fun transformArgumentList(argumentList: FirArgumentList, parent: FirElement): FirArgumentList = - argumentList(argumentList, parent) - - var call: (call: FirCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformCall(call: FirCall, parent: FirElement): FirStatement = - call(call, parent) - - var annotation: (annotation: FirAnnotation, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformAnnotation(annotation: FirAnnotation, parent: FirElement): FirStatement = - annotation(annotation, parent) - - var annotationCall: (annotationCall: FirAnnotationCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformAnnotationCall(annotationCall: FirAnnotationCall, parent: FirElement): FirStatement = - annotationCall(annotationCall, parent) - - var annotationArgumentMapping: (annotationArgumentMapping: FirAnnotationArgumentMapping, parent: FirElement) -> FirAnnotationArgumentMapping = - { el, _ -> el } - - override fun transformAnnotationArgumentMapping( - annotationArgumentMapping: FirAnnotationArgumentMapping, - parent: FirElement - ): FirAnnotationArgumentMapping = - annotationArgumentMapping(annotationArgumentMapping, parent) - - var errorAnnotationCall: (errorAnnotationCall: FirErrorAnnotationCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, parent: FirElement): FirStatement = - errorAnnotationCall(errorAnnotationCall, parent) - - var comparisonExpression: (comparisonExpression: FirComparisonExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, parent: FirElement): FirStatement = - comparisonExpression(comparisonExpression, parent) - - var typeOperatorCall: (typeOperatorCall: FirTypeOperatorCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, parent: FirElement): FirStatement = - typeOperatorCall(typeOperatorCall, parent) - - var assignmentOperatorStatement: (assignmentOperatorStatement: FirAssignmentOperatorStatement, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformAssignmentOperatorStatement( - assignmentOperatorStatement: FirAssignmentOperatorStatement, - parent: FirElement - ): FirStatement = - assignmentOperatorStatement(assignmentOperatorStatement, parent) - - var equalityOperatorCall: (equalityOperatorCall: FirEqualityOperatorCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, parent: FirElement): FirStatement = - equalityOperatorCall(equalityOperatorCall, parent) - - var whenExpression: (whenExpression: FirWhenExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformWhenExpression(whenExpression: FirWhenExpression, parent: FirElement): FirStatement = - whenExpression(whenExpression, parent) - - var whenBranch: (whenBranch: FirWhenBranch, parent: FirElement) -> FirWhenBranch = { el, _ -> el } - override fun transformWhenBranch(whenBranch: FirWhenBranch, parent: FirElement): FirWhenBranch = - whenBranch(whenBranch, parent) - - var contextReceiverArgumentListOwner: (contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, parent: FirElement) -> FirContextReceiverArgumentListOwner = - { el, _ -> el } - - override fun transformContextReceiverArgumentListOwner( - contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, - parent: FirElement - ): FirContextReceiverArgumentListOwner = - contextReceiverArgumentListOwner(contextReceiverArgumentListOwner, parent) - - var qualifiedAccess: (qualifiedAccess: FirQualifiedAccess, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, parent: FirElement): FirStatement = - qualifiedAccess(qualifiedAccess, parent) - - var checkNotNullCall: (checkNotNullCall: FirCheckNotNullCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, parent: FirElement): FirStatement = - checkNotNullCall(checkNotNullCall, parent) - - var elvisExpression: (elvisExpression: FirElvisExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformElvisExpression(elvisExpression: FirElvisExpression, parent: FirElement): FirStatement = - elvisExpression(elvisExpression, parent) - - var arrayOfCall: (arrayOfCall: FirArrayOfCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, parent: FirElement): FirStatement = - arrayOfCall(arrayOfCall, parent) - - var augmentedArraySetCall: (augmentedArraySetCall: FirAugmentedArraySetCall, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformAugmentedArraySetCall( - augmentedArraySetCall: FirAugmentedArraySetCall, - parent: FirElement - ): FirStatement = - augmentedArraySetCall(augmentedArraySetCall, parent) - - var classReferenceExpression: (classReferenceExpression: FirClassReferenceExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformClassReferenceExpression( - classReferenceExpression: FirClassReferenceExpression, - parent: FirElement - ): FirStatement = - classReferenceExpression(classReferenceExpression, parent) - - var errorExpression: (errorExpression: FirErrorExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformErrorExpression(errorExpression: FirErrorExpression, parent: FirElement): FirStatement = - errorExpression(errorExpression, parent) - - var errorFunction: (errorFunction: FirErrorFunction, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformErrorFunction(errorFunction: FirErrorFunction, parent: FirElement): FirStatement = - errorFunction(errorFunction, parent) - - var errorProperty: (errorProperty: FirErrorProperty, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformErrorProperty(errorProperty: FirErrorProperty, parent: FirElement): FirStatement = - errorProperty(errorProperty, parent) - - var danglingModifierList: (danglingModifierList: FirDanglingModifierList, parent: FirElement) -> FirDanglingModifierList = - { el, _ -> el } - - override fun transformDanglingModifierList( - danglingModifierList: FirDanglingModifierList, - parent: FirElement - ): FirDanglingModifierList = - danglingModifierList(danglingModifierList, parent) - - var qualifiedAccessExpression: (qualifiedAccessExpression: FirQualifiedAccessExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformQualifiedAccessExpression( - qualifiedAccessExpression: FirQualifiedAccessExpression, - parent: FirElement - ): FirStatement = - qualifiedAccessExpression(qualifiedAccessExpression, parent) - - var qualifiedErrorAccessExpression: (qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformQualifiedErrorAccessExpression( - qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, - parent: FirElement - ): FirStatement = - qualifiedErrorAccessExpression(qualifiedErrorAccessExpression, parent) - - var propertyAccessExpression: (propertyAccessExpression: FirPropertyAccessExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformPropertyAccessExpression( - propertyAccessExpression: FirPropertyAccessExpression, - parent: FirElement - ): FirStatement = - propertyAccessExpression(propertyAccessExpression, parent) - - var functionCall: (functionCall: FirFunctionCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformFunctionCall(functionCall: FirFunctionCall, parent: FirElement): FirStatement = - functionCall(functionCall, parent) - - var integerLiteralOperatorCall: (integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformIntegerLiteralOperatorCall( - integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, - parent: FirElement - ): FirStatement = - integerLiteralOperatorCall(integerLiteralOperatorCall, parent) - - var implicitInvokeCall: (implicitInvokeCall: FirImplicitInvokeCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, parent: FirElement): FirStatement = - implicitInvokeCall(implicitInvokeCall, parent) - - var delegatedConstructorCall: (delegatedConstructorCall: FirDelegatedConstructorCall, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformDelegatedConstructorCall( - delegatedConstructorCall: FirDelegatedConstructorCall, - parent: FirElement - ): FirStatement = - delegatedConstructorCall(delegatedConstructorCall, parent) - - var componentCall: (componentCall: FirComponentCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformComponentCall(componentCall: FirComponentCall, parent: FirElement): FirStatement = - componentCall(componentCall, parent) - - var callableReferenceAccess: (callableReferenceAccess: FirCallableReferenceAccess, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformCallableReferenceAccess( - callableReferenceAccess: FirCallableReferenceAccess, - parent: FirElement - ): FirStatement = - callableReferenceAccess(callableReferenceAccess, parent) - - var thisReceiverExpression: (thisReceiverExpression: FirThisReceiverExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformThisReceiverExpression( - thisReceiverExpression: FirThisReceiverExpression, - parent: FirElement - ): FirStatement = - thisReceiverExpression(thisReceiverExpression, parent) - - var smartCastExpression: (smartCastExpression: FirSmartCastExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformSmartCastExpression(smartCastExpression: FirSmartCastExpression, parent: FirElement): FirStatement = - smartCastExpression(smartCastExpression, parent) - - var safeCallExpression: (safeCallExpression: FirSafeCallExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformSafeCallExpression(safeCallExpression: FirSafeCallExpression, parent: FirElement): FirStatement = - safeCallExpression(safeCallExpression, parent) - - var checkedSafeCallSubject: (checkedSafeCallSubject: FirCheckedSafeCallSubject, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformCheckedSafeCallSubject( - checkedSafeCallSubject: FirCheckedSafeCallSubject, - parent: FirElement - ): FirStatement = - checkedSafeCallSubject(checkedSafeCallSubject, parent) - - var getClassCall: (getClassCall: FirGetClassCall, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformGetClassCall(getClassCall: FirGetClassCall, parent: FirElement): FirStatement = - getClassCall(getClassCall, parent) - - var wrappedExpression: (wrappedExpression: FirWrappedExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformWrappedExpression(wrappedExpression: FirWrappedExpression, parent: FirElement): FirStatement = - wrappedExpression(wrappedExpression, parent) - - var wrappedArgumentExpression: (wrappedArgumentExpression: FirWrappedArgumentExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformWrappedArgumentExpression( - wrappedArgumentExpression: FirWrappedArgumentExpression, - parent: FirElement - ): FirStatement = - wrappedArgumentExpression(wrappedArgumentExpression, parent) - - var lambdaArgumentExpression: (lambdaArgumentExpression: FirLambdaArgumentExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformLambdaArgumentExpression( - lambdaArgumentExpression: FirLambdaArgumentExpression, - parent: FirElement - ): FirStatement = - lambdaArgumentExpression(lambdaArgumentExpression, parent) - - var spreadArgumentExpression: (spreadArgumentExpression: FirSpreadArgumentExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformSpreadArgumentExpression( - spreadArgumentExpression: FirSpreadArgumentExpression, - parent: FirElement - ): FirStatement = - spreadArgumentExpression(spreadArgumentExpression, parent) - - var namedArgumentExpression: (namedArgumentExpression: FirNamedArgumentExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformNamedArgumentExpression( - namedArgumentExpression: FirNamedArgumentExpression, - parent: FirElement - ): FirStatement = - namedArgumentExpression(namedArgumentExpression, parent) - - var varargArgumentsExpression: (varargArgumentsExpression: FirVarargArgumentsExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformVarargArgumentsExpression( - varargArgumentsExpression: FirVarargArgumentsExpression, - parent: FirElement - ): FirStatement = - varargArgumentsExpression(varargArgumentsExpression, parent) - - var resolvedQualifier: (resolvedQualifier: FirResolvedQualifier, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, parent: FirElement): FirStatement = - resolvedQualifier(resolvedQualifier, parent) - - var errorResolvedQualifier: (errorResolvedQualifier: FirErrorResolvedQualifier, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformErrorResolvedQualifier( - errorResolvedQualifier: FirErrorResolvedQualifier, - parent: FirElement - ): FirStatement = - errorResolvedQualifier(errorResolvedQualifier, parent) - - var resolvedReifiedParameterReference: (resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformResolvedReifiedParameterReference( - resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, - parent: FirElement - ): FirStatement = - resolvedReifiedParameterReference(resolvedReifiedParameterReference, parent) - - var returnExpression: (returnExpression: FirReturnExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformReturnExpression(returnExpression: FirReturnExpression, parent: FirElement): FirStatement = - returnExpression(returnExpression, parent) - - var stringConcatenationCall: (stringConcatenationCall: FirStringConcatenationCall, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformStringConcatenationCall( - stringConcatenationCall: FirStringConcatenationCall, - parent: FirElement - ): FirStatement = - stringConcatenationCall(stringConcatenationCall, parent) - - var throwExpression: (throwExpression: FirThrowExpression, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformThrowExpression(throwExpression: FirThrowExpression, parent: FirElement): FirStatement = - throwExpression(throwExpression, parent) - - var variableAssignment: (variableAssignment: FirVariableAssignment, parent: FirElement) -> FirStatement = { el, _ -> el } - override fun transformVariableAssignment(variableAssignment: FirVariableAssignment, parent: FirElement): FirStatement = - variableAssignment(variableAssignment, parent) - - var whenSubjectExpression: (whenSubjectExpression: FirWhenSubjectExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformWhenSubjectExpression( - whenSubjectExpression: FirWhenSubjectExpression, - parent: FirElement - ): FirStatement = - whenSubjectExpression(whenSubjectExpression, parent) - - var wrappedDelegateExpression: (wrappedDelegateExpression: FirWrappedDelegateExpression, parent: FirElement) -> FirStatement = - { el, _ -> el } - - override fun transformWrappedDelegateExpression( - wrappedDelegateExpression: FirWrappedDelegateExpression, - parent: FirElement - ): FirStatement = - wrappedDelegateExpression(wrappedDelegateExpression, parent) - - var namedReference: (namedReference: FirNamedReference, parent: FirElement) -> FirReference = { el, _ -> el } - override fun transformNamedReference(namedReference: FirNamedReference, parent: FirElement): FirReference = - namedReference(namedReference, parent) - - var namedReferenceWithCandidateBase: (namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, parent: FirElement) -> FirReference = - { el, _ -> el } - - override fun transformNamedReferenceWithCandidateBase( - namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, - parent: FirElement - ): FirReference = - namedReferenceWithCandidateBase(namedReferenceWithCandidateBase, parent) - - var errorNamedReference: (errorNamedReference: FirErrorNamedReference, parent: FirElement) -> FirReference = { el, _ -> el } - override fun transformErrorNamedReference(errorNamedReference: FirErrorNamedReference, parent: FirElement): FirReference = - errorNamedReference(errorNamedReference, parent) - - var superReference: (superReference: FirSuperReference, parent: FirElement) -> FirReference = { el, _ -> el } - override fun transformSuperReference(superReference: FirSuperReference, parent: FirElement): FirReference = - superReference(superReference, parent) - - var thisReference: (thisReference: FirThisReference, parent: FirElement) -> FirReference = { el, _ -> el } - override fun transformThisReference(thisReference: FirThisReference, parent: FirElement): FirReference = - thisReference(thisReference, parent) - - var controlFlowGraphReference: (controlFlowGraphReference: FirControlFlowGraphReference, parent: FirElement) -> FirReference = - { el, _ -> el } - - override fun transformControlFlowGraphReference( - controlFlowGraphReference: FirControlFlowGraphReference, - parent: FirElement - ): FirReference = - controlFlowGraphReference(controlFlowGraphReference, parent) - - var resolvedNamedReference: (resolvedNamedReference: FirResolvedNamedReference, parent: FirElement) -> FirReference = - { el, _ -> el } - - override fun transformResolvedNamedReference( - resolvedNamedReference: FirResolvedNamedReference, - parent: FirElement - ): FirReference = - resolvedNamedReference(resolvedNamedReference, parent) - - var resolvedErrorReference: (resolvedErrorReference: FirResolvedErrorReference, parent: FirElement) -> FirReference = - { el, _ -> el } - - override fun transformResolvedErrorReference( - resolvedErrorReference: FirResolvedErrorReference, - parent: FirElement - ): FirReference = - resolvedErrorReference(resolvedErrorReference, parent) - - var delegateFieldReference: (delegateFieldReference: FirDelegateFieldReference, parent: FirElement) -> FirReference = - { el, _ -> el } - - override fun transformDelegateFieldReference( - delegateFieldReference: FirDelegateFieldReference, - parent: FirElement - ): FirReference = - delegateFieldReference(delegateFieldReference, parent) - - var backingFieldReference: (backingFieldReference: FirBackingFieldReference, parent: FirElement) -> FirReference = - { el, _ -> el } - - override fun transformBackingFieldReference( - backingFieldReference: FirBackingFieldReference, - parent: FirElement - ): FirReference = - backingFieldReference(backingFieldReference, parent) - - var resolvedCallableReference: (resolvedCallableReference: FirResolvedCallableReference, parent: FirElement) -> FirReference = - { el, _ -> el } - - override fun transformResolvedCallableReference( - resolvedCallableReference: FirResolvedCallableReference, - parent: FirElement - ): FirReference = - resolvedCallableReference(resolvedCallableReference, parent) - - var resolvedTypeRef: (resolvedTypeRef: FirResolvedTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } - override fun transformResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, parent: FirElement): FirTypeRef = - resolvedTypeRef(resolvedTypeRef, parent) - - var errorTypeRef: (errorTypeRef: FirErrorTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } - override fun transformErrorTypeRef(errorTypeRef: FirErrorTypeRef, parent: FirElement): FirTypeRef = - errorTypeRef(errorTypeRef, parent) - - var typeRefWithNullability: (typeRefWithNullability: FirTypeRefWithNullability, parent: FirElement) -> FirTypeRef = - { el, _ -> el } - - override fun transformTypeRefWithNullability( - typeRefWithNullability: FirTypeRefWithNullability, - parent: FirElement - ): FirTypeRef = - typeRefWithNullability(typeRefWithNullability, parent) - - var userTypeRef: (userTypeRef: FirUserTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } - override fun transformUserTypeRef(userTypeRef: FirUserTypeRef, parent: FirElement): FirTypeRef = - userTypeRef(userTypeRef, parent) - - var dynamicTypeRef: (dynamicTypeRef: FirDynamicTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } - override fun transformDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, parent: FirElement): FirTypeRef = - dynamicTypeRef(dynamicTypeRef, parent) - - var functionTypeRef: (functionTypeRef: FirFunctionTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } - override fun transformFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, parent: FirElement): FirTypeRef = - functionTypeRef(functionTypeRef, parent) - - var intersectionTypeRef: (intersectionTypeRef: FirIntersectionTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } - override fun transformIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, parent: FirElement): FirTypeRef = - intersectionTypeRef(intersectionTypeRef, parent) - - var implicitTypeRef: (implicitTypeRef: FirImplicitTypeRef, parent: FirElement) -> FirTypeRef = { el, _ -> el } - override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, parent: FirElement): FirTypeRef = - implicitTypeRef(implicitTypeRef, parent) - - var effectDeclaration: (effectDeclaration: FirEffectDeclaration, parent: FirElement) -> FirEffectDeclaration = { el, _ -> el } - override fun transformEffectDeclaration(effectDeclaration: FirEffectDeclaration, parent: FirElement): FirEffectDeclaration = - effectDeclaration(effectDeclaration, parent) - - var contractDescription: (contractDescription: FirContractDescription, parent: FirElement) -> FirContractDescription = - { el, _ -> el } - - override fun transformContractDescription( - contractDescription: FirContractDescription, - parent: FirElement - ): FirContractDescription = - contractDescription(contractDescription, parent) - - var legacyRawContractDescription: (legacyRawContractDescription: FirLegacyRawContractDescription, parent: FirElement) -> FirContractDescription = - { el, _ -> el } - - override fun transformLegacyRawContractDescription( - legacyRawContractDescription: FirLegacyRawContractDescription, - parent: FirElement - ): FirContractDescription = - legacyRawContractDescription(legacyRawContractDescription, parent) - - var rawContractDescription: (rawContractDescription: FirRawContractDescription, parent: FirElement) -> FirContractDescription = - { el, _ -> el } - - override fun transformRawContractDescription( - rawContractDescription: FirRawContractDescription, - parent: FirElement - ): FirContractDescription = - rawContractDescription(rawContractDescription, parent) - - var resolvedContractDescription: (resolvedContractDescription: FirResolvedContractDescription, parent: FirElement) -> FirContractDescription = - { el, _ -> el } - - override fun transformResolvedContractDescription( - resolvedContractDescription: FirResolvedContractDescription, - parent: FirElement - ): FirContractDescription = - resolvedContractDescription(resolvedContractDescription, parent) - - } - - companion object { - operator fun invoke(init: Builder.() -> Unit): (FirSession) -> Transformer = - { Builder(it).apply(init) } - } - -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/TypeAttributes.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/TypeAttributes.kt deleted file mode 100644 index 702b460..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/TypeAttributes.kt +++ /dev/null @@ -1,24 +0,0 @@ -package arrow.meta.plugins - -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.expressions.FirAnnotation -import org.jetbrains.kotlin.fir.types.ConeAttribute - -interface TypeAttributes : FrontendPlugin { - fun convertAttributeToAnnotation(attribute: ConeAttribute<*>): FirAnnotation? - fun extractAttributeFromAnnotation(annotation: FirAnnotation): ConeAttribute<*>? - class Builder(override val session: FirSession) : TypeAttributes, FrontendPlugin.Builder() { - var attributeToAnnotation: (ConeAttribute<*>) -> FirAnnotation? = { null } - var attributeFromAnnotation: (FirAnnotation) -> ConeAttribute<*>? = { null } - override fun convertAttributeToAnnotation(attribute: ConeAttribute<*>): FirAnnotation? = - attributeToAnnotation(attribute) - - override fun extractAttributeFromAnnotation(annotation: FirAnnotation): ConeAttribute<*>? = - attributeFromAnnotation(annotation) - } - - companion object { - operator fun invoke(init: Builder.() -> Unit): (FirSession) -> TypeAttributes = - { Builder(it).apply(init) } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/example/ExampleFull.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/example/ExampleFull.kt deleted file mode 100644 index 4e4f9c4..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/plugins/example/ExampleFull.kt +++ /dev/null @@ -1,77 +0,0 @@ -package arrow.meta.plugins.example - -import arrow.meta.Meta -import arrow.meta.plugins.* - - -/** - * A global compiler plugin that mirrors the extensions - * in the Kotlin compiler - */ -@Meta -class MyCompilerPluginWithDSL : FrontendPlugin.Builder() { - init { - +Supertypes { - shouldTransformSupertypes = { false } - additionalSupertypes = { _, _ -> emptyList() } - } - +ScriptConfigurator { - configureScript = { fileBuilder -> } - } - +SAMConversionTransformer { - getCustomFunctionalTypeForSamConversion = { function -> null } - } - +ExpressionResolution { - newImplicitReceivers = { emptyList() } - } - +Checkers { - expressionCheckers.add { expression, context, reporter -> } - declarationCheckers.add { declaration, context, reporter -> } - typeCheckers.add { type, context, reporter -> } - } - +Generation { - callableNamesForClass = { emptySet() } - nestedClassifiersNames = { emptySet() } - topLevelCallableIds = { emptySet() } - topLevelClassIds = { emptySet() } - containsPackage = { false } - classLikeDeclaration = { null } - constructors = { emptyList() } - functions = { _, _ -> emptyList() } - properties = { _, _ -> emptyList() } - } - +Transformer { - file = { file, _ -> file } - declaration = { declaration, _ -> declaration } - expression = { expression, _ -> expression } - statement = { statement, _ -> statement } - typeAlias = { typeAlias, _ -> typeAlias } - typeParameter = { typeParameter, _ -> typeParameter } - valueParameter = { valueParameter, _ -> valueParameter } - property = { property, _ -> property } - function = { function, _ -> function } - classLikeDeclaration = { classLikeDeclaration, _ -> classLikeDeclaration } - typeRef = { typeRef, _ -> typeRef } - annotation = { annotation, _ -> annotation } - call = { call, _ -> call } - import = { import, _ -> import } - loop = { loop, _ -> loop } - jump = { jump, _ -> jump } - whenExpression = { whenExpression, _ -> whenExpression } - tryExpression = { tryExpression, _ -> tryExpression } - catch = { catch, _ -> catch } - block = { block, _ -> block } - qualifiedAccess = { qualifiedAccess, _ -> qualifiedAccess } - variableAssignment = { variableAssignment, _ -> variableAssignment } - binaryLogicExpression = { binaryLogicExpression, _ -> binaryLogicExpression } - backingField = { backingField, _ -> backingField } - backingFieldReference = { backingFieldReference, _ -> backingFieldReference } - delegatedConstructorCall = { delegatedConstructorCall, _ -> delegatedConstructorCall } - enumEntry = { enumEntry, _ -> enumEntry } - errorExpression = { errorExpression, _ -> errorExpression } - resolvedQualifier = { resolvedQualifier, _ -> resolvedQualifier } - contextReceiver = { contextReceiver, _ -> contextReceiver } - elvisExpression = { elvisExpression, _ -> elvisExpression } - } - } -} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt index 34b450b..c9fb31a 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt @@ -2,6 +2,7 @@ package arrow.meta.samples import arrow.meta.FirMetaCheckerContext import arrow.meta.FirMetaContext +import arrow.meta.FirMetaMemberGenerationContext import arrow.meta.Meta import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.descriptors.ClassKind @@ -12,18 +13,15 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.expressions.FirGetClassCall import org.jetbrains.kotlin.fir.expressions.FirStatement -import org.jetbrains.kotlin.fir.extensions.predicate.LookupPredicate -import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.fqName import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider import org.jetbrains.kotlin.fir.symbols.SymbolInternals -import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.Variance import kotlin.reflect.* @@ -36,21 +34,19 @@ annotation class Reflect { companion object : //Meta.FrontendTransformer.RegularClass, Meta.FrontendTransformer.GetClassCall, - Meta.Generate.TopLevel.Class { + Meta.Generate.Members.NestedClasses { - override fun FirMetaContext.classes(): Set { - val reflected = session.predicateBasedProvider.getSymbolsByPredicate(LookupPredicate.create { annotatedOrUnder(FqName(Reflect::class.java.canonicalName)) }) - return reflected.filterIsInstance>().map { ClassId.fromString(it.classId.asFqNameString().replace(".", "/") + Reflect::class.java.simpleName) }.toSet() + override fun FirMetaMemberGenerationContext.nestedClasses(firClass: FirClassSymbol<*>): Set { + println("call to nestedClasses: ${firClass.classId}, annotations: ${firClass.annotations.joinToString()}") + return emptySet() } - @OptIn(SymbolInternals::class) - override fun FirMetaContext.classes(classId: ClassId): FirClass { - val targetClassId = ClassId.fromString(classId.asSingleFqName().asString().removeSuffix(Reflect::class.java.simpleName)) - val target = session.symbolProvider.getClassLikeSymbolByClassId(targetClassId)?.fir as? FirRegularClass - - return target?.let { compile(kClass(it)) } ?: error("Could not find class $targetClassId") + override fun FirMetaMemberGenerationContext.nestedClasses(classId: ClassId): List { + return emptyList() } + + // override fun FirMetaMemberGenerationContext.nestedClasses(firClass: FirClassSymbol<*>): Set { // val isReflected = // firClass.annotations.any { it.annotationTypeRef.source?.text == Reflect::class.java.simpleName } diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/FirArrowReflectExtensionRegistrar.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/FirArrowReflectExtensionRegistrar.kt index c72fb67..7956fb4 100644 --- a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/FirArrowReflectExtensionRegistrar.kt +++ b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/FirArrowReflectExtensionRegistrar.kt @@ -1,76 +1,16 @@ package arrow.reflect.compiler.plugin.fir import arrow.meta.TemplateCompiler -import arrow.meta.plugins.* import arrow.reflect.compiler.plugin.fir.checkers.FirMetaAdditionalCheckersExtension -import arrow.reflect.compiler.plugin.fir.codegen.CompilerPluginGenerationExtension import arrow.reflect.compiler.plugin.fir.codegen.FirMetaCodegenExtension import arrow.reflect.compiler.plugin.targets.MetaTarget -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.DeclarationCheckers -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirFileChecker -import org.jetbrains.kotlin.fir.analysis.checkers.expression.ExpressionCheckers -import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirBasicExpressionChecker -import org.jetbrains.kotlin.fir.analysis.checkers.type.FirTypeRefChecker -import org.jetbrains.kotlin.fir.analysis.checkers.type.TypeCheckers -import org.jetbrains.kotlin.fir.analysis.extensions.FirAdditionalCheckersExtension -import org.jetbrains.kotlin.fir.builder.FirScriptConfiguratorExtension -import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.declarations.builder.FirFileBuilder -import org.jetbrains.kotlin.fir.declarations.builder.FirScriptBuilder -import org.jetbrains.kotlin.fir.expressions.FirAnnotation -import org.jetbrains.kotlin.fir.expressions.FirFunctionCall -import org.jetbrains.kotlin.fir.expressions.FirStatement -import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment -import org.jetbrains.kotlin.fir.extensions.* -import org.jetbrains.kotlin.fir.resolve.FirSamConversionTransformerExtension -import org.jetbrains.kotlin.fir.types.* -import kotlin.reflect.full.isSubclassOf +import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar class FirArrowReflectExtensionRegistrar(val templateCompiler: TemplateCompiler, val metaTargets: List) : FirExtensionRegistrar() { - private fun compilerPlugins(): Sequence<(FirSession) -> FrontendPlugin> = - metaTargets.filter { it.companion.isSubclassOf(FrontendPlugin.Builder::class) } - .map { it.companion.objectInstance } - .distinct() - .filterIsInstance() - .asSequence() - .flatMap { - it.plugins - } - override fun ExtensionRegistrarContext.configurePlugin() { - val compilerPlugins = compilerPlugins() - compilerPlugins.forEach { pluginFn -> - val registration = { session: FirSession -> - val plugin = pluginFn(session) - val result = when (plugin) { - is Supertypes -> registerSuperTypes(plugin) - is StatusTransformer -> registerStatusTransformer(plugin) - is AssignmentTransformer -> registerAssignmentTransformer(plugin) - is Checkers -> registerCheckers(plugin) - is ExpressionResolution -> registerExpressionResolution(plugin) - is Generation -> registerGeneration(plugin) - is SAMConversionTransformer -> registerSAMConversionTransformer(plugin) - is ScriptConfigurator -> registerScriptConfigurator(plugin) - is Transformer -> registerTransformer(plugin) - is TypeAttributes -> registerTypeAttributes(plugin) - } - result - } - - +{ session: FirSession -> - templateCompiler.session = session - FirMetaCodegenExtension(session, templateCompiler, metaTargets) - } - } - - //todo remove old stuff below when compiler plugin is ready +{ session: FirSession -> templateCompiler.session = session FirMetaCodegenExtension(session, templateCompiler, metaTargets) @@ -81,129 +21,5 @@ class FirArrowReflectExtensionRegistrar(val templateCompiler: TemplateCompiler, } } - private fun ExtensionRegistrarContext.registerTransformer(plugin: Transformer) = - object : FirAdditionalCheckersExtension(plugin.session) { - override val declarationCheckers: DeclarationCheckers - get() = object : DeclarationCheckers() { - override val fileCheckers: Set - get() = setOf(object : FirFileChecker() { - override fun check(declaration: FirFile, context: CheckerContext, reporter: DiagnosticReporter) { - declaration.transform(MetaFirTransformer(plugin), declaration) - } - }) - } - } - - - private fun registerTypeAttributes(plugin: TypeAttributes): FirTypeAttributeExtension = - object : FirTypeAttributeExtension(plugin.session) { - override fun convertAttributeToAnnotation(attribute: ConeAttribute<*>): FirAnnotation? { - return plugin.convertAttributeToAnnotation(attribute) - } - - override fun extractAttributeFromAnnotation(annotation: FirAnnotation): ConeAttribute<*>? { - return plugin.extractAttributeFromAnnotation(annotation) - } - } - - - private fun registerScriptConfigurator(plugin: ScriptConfigurator) = - object : FirScriptConfiguratorExtension(plugin.session) { - override fun FirScriptBuilder.configure(fileBuilder: FirFileBuilder) { - plugin.run { configure(fileBuilder) } - } - } - - - private fun registerSAMConversionTransformer(plugin: SAMConversionTransformer) = - object : FirSamConversionTransformerExtension(plugin.session) { - override fun getCustomFunctionalTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? { - return plugin.getCustomFunctionalTypeForSamConversion(function) - } - } - - - private fun registerGeneration(plugin: Generation) = - CompilerPluginGenerationExtension(plugin.session, plugin) - - private fun registerExpressionResolution(plugin: ExpressionResolution) = - object : FirExpressionResolutionExtension(plugin.session) { - override fun addNewImplicitReceivers(functionCall: FirFunctionCall): List { - return plugin.addNewImplicitReceivers(functionCall) - } - } - - - private fun registerCheckers(plugin: Checkers) = - object : FirAdditionalCheckersExtension(plugin.session) { - override val declarationCheckers: DeclarationCheckers - get() = object : DeclarationCheckers() { - override val basicDeclarationCheckers: Set - get() = plugin.declarationCheckers.map { - object : FirBasicDeclarationChecker() { - override fun check( - declaration: FirDeclaration, - context: CheckerContext, - reporter: DiagnosticReporter - ) { - it.check(declaration, context, reporter) - } - } - }.toSet() - } - override val expressionCheckers: ExpressionCheckers - get() = object : ExpressionCheckers() { - override val basicExpressionCheckers: Set - get() = plugin.expressionCheckers.map { - object : FirBasicExpressionChecker() { - override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) { - it.check(expression, context, reporter) - } - } - }.toSet() - } - override val typeCheckers: TypeCheckers - get() = object : TypeCheckers() { - override val typeRefCheckers: Set - get() = plugin.typeCheckers.map { - object : FirTypeRefChecker() { - override fun check(typeRef: FirTypeRef, context: CheckerContext, reporter: DiagnosticReporter) { - it.check(typeRef, context, reporter) - } - } - }.toSet() - } - } - - - private fun registerAssignmentTransformer(plugin: AssignmentTransformer) = - object : FirAssignExpressionAltererExtension(plugin.session) { - override fun transformVariableAssignment(variableAssignment: FirVariableAssignment): FirStatement? { - return plugin.transformVariableAssignment(variableAssignment) - } - } - - private fun registerSuperTypes(plugin: Supertypes): FirSupertypeGenerationExtension = - object : FirSupertypeGenerationExtension(plugin.session) { - context(TypeResolveServiceContainer) override fun computeAdditionalSupertypes( - classLikeDeclaration: FirClassLikeDeclaration, - resolvedSupertypes: List - ): List = - plugin.computeAdditionalSupertypes(classLikeDeclaration, resolvedSupertypes) - - override fun needTransformSupertypes(declaration: FirClassLikeDeclaration): Boolean = - plugin.needTransformSupertypes(declaration) - } - - private fun registerStatusTransformer(plugin: StatusTransformer) = - object : FirStatusTransformerExtension(plugin.session) { - override fun needTransformStatus(declaration: FirDeclaration): Boolean = - plugin.needTransformStatus(declaration) - - override fun transformStatus(status: FirDeclarationStatus, declaration: FirDeclaration): FirDeclarationStatus = - plugin.transformStatus(status, declaration) - } - - } diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/CompilerPluginGenerationExtension.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/CompilerPluginGenerationExtension.kt deleted file mode 100644 index 1331d6d..0000000 --- a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/codegen/CompilerPluginGenerationExtension.kt +++ /dev/null @@ -1,58 +0,0 @@ -package arrow.reflect.compiler.plugin.fir.codegen - -import arrow.meta.plugins.Generation -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension -import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar -import org.jetbrains.kotlin.fir.extensions.MemberGenerationContext -import org.jetbrains.kotlin.fir.symbols.impl.* -import org.jetbrains.kotlin.name.CallableId -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name - -class CompilerPluginGenerationExtension(session: FirSession, val compilerPlugin: Generation) : - FirDeclarationGenerationExtension(session) { - override fun generateClassLikeDeclaration(classId: ClassId): FirClassLikeSymbol<*>? { - return compilerPlugin.generateClassLikeDeclaration(classId) - } - - override fun generateConstructors(context: MemberGenerationContext): List { - return compilerPlugin.generateConstructors(context) - } - - override fun generateFunctions( - callableId: CallableId, - context: MemberGenerationContext? - ): List { - return compilerPlugin.generateFunctions(callableId, context) - } - - override fun generateProperties(callableId: CallableId, context: MemberGenerationContext?): List { - return compilerPlugin.generateProperties(callableId, context) - } - - override fun getCallableNamesForClass(classSymbol: FirClassSymbol<*>): Set { - return compilerPlugin.getCallableNamesForClass(classSymbol) - } - - override fun getNestedClassifiersNames(classSymbol: FirClassSymbol<*>): Set { - return compilerPlugin.getNestedClassifiersNames(classSymbol) - } - - override fun getTopLevelCallableIds(): Set { - return compilerPlugin.getTopLevelCallableIds() - } - - override fun getTopLevelClassIds(): Set { - return compilerPlugin.getTopLevelClassIds() - } - - override fun hasPackage(packageFqName: FqName): Boolean { - return compilerPlugin.hasPackage(packageFqName) - } - - override fun FirDeclarationPredicateRegistrar.registerPredicates() { - register(compilerPlugin.metaAnnotatedPredicate) - } -} diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/transformers/FirMetaTransformer.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/transformers/FirMetaTransformer.kt index a98209e..e3e1e86 100644 --- a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/transformers/FirMetaTransformer.kt +++ b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/transformers/FirMetaTransformer.kt @@ -54,12 +54,10 @@ class FirMetaTransformer( } override fun transformElement(element: E, data: FirDeclaration): E { - val result = if (element is FirAnnotationContainer) { - invokeMeta(data, element) ?: element + element.transformChildren(this, data) + return if (element is FirAnnotationContainer) { + invokeMeta(data, element) as E? ?: element } else element - //val context = element as? FirDeclaration ?: data - result.transformChildren(this, data) - return result as E } } diff --git a/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.ir.txt b/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.ir.txt deleted file mode 100644 index 91e2162..0000000 --- a/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.ir.txt +++ /dev/null @@ -1,172 +0,0 @@ -FILE fqName:foo.bar fileName:/reflect_test.kt - CLASS ANNOTATION_CLASS name:Test modality:OPEN visibility:public superTypes:[kotlin.Annotation] - $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:foo.bar.Test - CONSTRUCTOR visibility:public <> () returnType:foo.bar.Test [primary] - BLOCK_BODY - DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' - INSTANCE_INITIALIZER_CALL classDescriptor='CLASS ANNOTATION_CLASS name:Test modality:OPEN visibility:public superTypes:[kotlin.Annotation]' - FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] - overridden: - public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in kotlin.Annotation - $this: VALUE_PARAMETER name: type:kotlin.Any - VALUE_PARAMETER name:other index:0 type:kotlin.Any? - FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] - overridden: - public open fun hashCode (): kotlin.Int [fake_override] declared in kotlin.Annotation - $this: VALUE_PARAMETER name: type:kotlin.Any - FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] - overridden: - public open fun toString (): kotlin.String [fake_override] declared in kotlin.Annotation - $this: VALUE_PARAMETER name: type:kotlin.Any - CLASS CLASS name:Sample modality:FINAL visibility:public [data] superTypes:[kotlin.Any] - annotations: - Reflect - $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:foo.bar.Sample - CONSTRUCTOR visibility:public <> (name:kotlin.String, age:kotlin.Int) returnType:foo.bar.Sample [primary] - VALUE_PARAMETER name:name index:0 type:kotlin.String - VALUE_PARAMETER name:age index:1 type:kotlin.Int - BLOCK_BODY - DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' - INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Sample modality:FINAL visibility:public [data] superTypes:[kotlin.Any]' - PROPERTY name:name visibility:public modality:FINAL [val] - FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final] - EXPRESSION_BODY - GET_VAR 'name: kotlin.String declared in foo.bar.Sample.' type=kotlin.String origin=INITIALIZE_PROPERTY_FROM_PARAMETER - FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> ($this:foo.bar.Sample) returnType:kotlin.String - correspondingProperty: PROPERTY name:name visibility:public modality:FINAL [val] - $this: VALUE_PARAMETER name: type:foo.bar.Sample - BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun (): kotlin.String declared in foo.bar.Sample' - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.' type=foo.bar.Sample origin=null - PROPERTY name:age visibility:public modality:FINAL [val] - FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final] - EXPRESSION_BODY - GET_VAR 'age: kotlin.Int declared in foo.bar.Sample.' type=kotlin.Int origin=INITIALIZE_PROPERTY_FROM_PARAMETER - FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> ($this:foo.bar.Sample) returnType:kotlin.Int - correspondingProperty: PROPERTY name:age visibility:public modality:FINAL [val] - $this: VALUE_PARAMETER name: type:foo.bar.Sample - BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in foo.bar.Sample' - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.' type=foo.bar.Sample origin=null - FUN name:component1 visibility:public modality:FINAL <> ($this:foo.bar.Sample) returnType:kotlin.String [operator] - $this: VALUE_PARAMETER name: type:foo.bar.Sample - BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun component1 (): kotlin.String [operator] declared in foo.bar.Sample' - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.component1' type=foo.bar.Sample origin=null - FUN name:component2 visibility:public modality:FINAL <> ($this:foo.bar.Sample) returnType:kotlin.Int [operator] - $this: VALUE_PARAMETER name: type:foo.bar.Sample - BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun component2 (): kotlin.Int [operator] declared in foo.bar.Sample' - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.component2' type=foo.bar.Sample origin=null - FUN name:copy visibility:public modality:FINAL <> ($this:foo.bar.Sample, name:kotlin.String, age:kotlin.Int) returnType:foo.bar.Sample - $this: VALUE_PARAMETER name: type:foo.bar.Sample - VALUE_PARAMETER name:name index:0 type:kotlin.String - EXPRESSION_BODY - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.copy' type=foo.bar.Sample origin=null - VALUE_PARAMETER name:age index:1 type:kotlin.Int - EXPRESSION_BODY - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.copy' type=foo.bar.Sample origin=null - BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun copy (name: kotlin.String, age: kotlin.Int): foo.bar.Sample declared in foo.bar.Sample' - CONSTRUCTOR_CALL 'public constructor (name: kotlin.String, age: kotlin.Int) [primary] declared in foo.bar.Sample' type=foo.bar.Sample origin=null - name: GET_VAR 'name: kotlin.String declared in foo.bar.Sample.copy' type=kotlin.String origin=null - age: GET_VAR 'age: kotlin.Int declared in foo.bar.Sample.copy' type=kotlin.Int origin=null - FUN GENERATED_DATA_CLASS_MEMBER name:equals visibility:public modality:OPEN <> ($this:foo.bar.Sample, other:kotlin.Any?) returnType:kotlin.Boolean - overridden: - public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any - $this: VALUE_PARAMETER GENERATED_DATA_CLASS_MEMBER name: type:foo.bar.Sample - VALUE_PARAMETER GENERATED_DATA_CLASS_MEMBER name:other index:0 type:kotlin.Any? - BLOCK_BODY - WHEN type=kotlin.Unit origin=null - BRANCH - if: CALL 'public final fun EQEQEQ (arg0: kotlin.Any?, arg1: kotlin.Any?): kotlin.Boolean declared in kotlin.internal.ir' type=kotlin.Boolean origin=EQEQEQ - arg0: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.equals' type=foo.bar.Sample origin=null - arg1: GET_VAR 'other: kotlin.Any? declared in foo.bar.Sample.equals' type=kotlin.Any? origin=null - then: RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in foo.bar.Sample' - CONST Boolean type=kotlin.Boolean value=true - WHEN type=kotlin.Unit origin=null - BRANCH - if: TYPE_OP type=kotlin.Boolean origin=NOT_INSTANCEOF typeOperand=foo.bar.Sample - GET_VAR 'other: kotlin.Any? declared in foo.bar.Sample.equals' type=kotlin.Any? origin=null - then: RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in foo.bar.Sample' - CONST Boolean type=kotlin.Boolean value=false - VAR IR_TEMPORARY_VARIABLE name:tmp_0 type:foo.bar.Sample [val] - TYPE_OP type=foo.bar.Sample origin=CAST typeOperand=foo.bar.Sample - GET_VAR 'other: kotlin.Any? declared in foo.bar.Sample.equals' type=kotlin.Any? origin=null - WHEN type=kotlin.Unit origin=null - BRANCH - if: CALL 'public final fun not (): kotlin.Boolean [operator] declared in kotlin.Boolean' type=kotlin.Boolean origin=EXCLEQ - $this: CALL 'public final fun EQEQ (arg0: kotlin.Any?, arg1: kotlin.Any?): kotlin.Boolean declared in kotlin.internal.ir' type=kotlin.Boolean origin=EXCLEQ - arg0: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.equals' type=foo.bar.Sample origin=null - arg1: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null - receiver: GET_VAR 'val tmp_0: foo.bar.Sample [val] declared in foo.bar.Sample.equals' type=foo.bar.Sample origin=null - then: RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in foo.bar.Sample' - CONST Boolean type=kotlin.Boolean value=false - WHEN type=kotlin.Unit origin=null - BRANCH - if: CALL 'public final fun not (): kotlin.Boolean [operator] declared in kotlin.Boolean' type=kotlin.Boolean origin=EXCLEQ - $this: CALL 'public final fun EQEQ (arg0: kotlin.Any?, arg1: kotlin.Any?): kotlin.Boolean declared in kotlin.internal.ir' type=kotlin.Boolean origin=EXCLEQ - arg0: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.equals' type=foo.bar.Sample origin=null - arg1: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null - receiver: GET_VAR 'val tmp_0: foo.bar.Sample [val] declared in foo.bar.Sample.equals' type=foo.bar.Sample origin=null - then: RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in foo.bar.Sample' - CONST Boolean type=kotlin.Boolean value=false - RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in foo.bar.Sample' - CONST Boolean type=kotlin.Boolean value=true - FUN GENERATED_DATA_CLASS_MEMBER name:hashCode visibility:public modality:OPEN <> ($this:foo.bar.Sample) returnType:kotlin.Int - overridden: - public open fun hashCode (): kotlin.Int declared in kotlin.Any - $this: VALUE_PARAMETER GENERATED_DATA_CLASS_MEMBER name: type:foo.bar.Sample - BLOCK_BODY - VAR name:result type:kotlin.Int [var] - CALL 'public open fun hashCode (): kotlin.Int [fake_override] declared in kotlin.String' type=kotlin.Int origin=null - $this: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.hashCode' type=foo.bar.Sample origin=null - SET_VAR 'var result: kotlin.Int [var] declared in foo.bar.Sample.hashCode' type=kotlin.Unit origin=EQ - CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null - $this: CALL 'public final fun times (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null - $this: GET_VAR 'var result: kotlin.Int [var] declared in foo.bar.Sample.hashCode' type=kotlin.Int origin=null - other: CONST Int type=kotlin.Int value=31 - other: CALL 'public open fun hashCode (): kotlin.Int [fake_override] declared in kotlin.Int' type=kotlin.Int origin=null - $this: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.hashCode' type=foo.bar.Sample origin=null - RETURN type=kotlin.Nothing from='public open fun hashCode (): kotlin.Int declared in foo.bar.Sample' - GET_VAR 'var result: kotlin.Int [var] declared in foo.bar.Sample.hashCode' type=kotlin.Int origin=null - FUN GENERATED_DATA_CLASS_MEMBER name:toString visibility:public modality:OPEN <> ($this:foo.bar.Sample) returnType:kotlin.String - overridden: - public open fun toString (): kotlin.String declared in kotlin.Any - $this: VALUE_PARAMETER GENERATED_DATA_CLASS_MEMBER name: type:foo.bar.Sample - BLOCK_BODY - RETURN type=kotlin.Nothing from='public open fun toString (): kotlin.String declared in foo.bar.Sample' - STRING_CONCATENATION type=kotlin.String - CONST String type=kotlin.String value="Sample(" - CONST String type=kotlin.String value="name=" - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:name type:kotlin.String visibility:private [final]' type=kotlin.String origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.toString' type=foo.bar.Sample origin=null - CONST String type=kotlin.String value=", " - CONST String type=kotlin.String value="age=" - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:age type:kotlin.Int visibility:private [final]' type=kotlin.Int origin=null - receiver: GET_VAR ': foo.bar.Sample declared in foo.bar.Sample.toString' type=foo.bar.Sample origin=null - CONST String type=kotlin.String value=")" - FUN name:box visibility:public modality:FINAL <> () returnType:kotlin.String - BLOCK_BODY - VAR name:x type:kotlin.reflect.KClass [val] - CLASS_REFERENCE 'CLASS CLASS name:Sample modality:FINAL visibility:public [data] superTypes:[kotlin.Any]' type=kotlin.reflect.KClass - RETURN type=kotlin.Nothing from='public final fun box (): kotlin.String declared in foo.bar' - WHEN type=kotlin.String origin=IF - BRANCH - if: TYPE_OP type=kotlin.Boolean origin=INSTANCEOF typeOperand=arrow.meta.samples.CompileTimeReflected<*> - GET_VAR 'val x: kotlin.reflect.KClass [val] declared in foo.bar.box' type=kotlin.reflect.KClass origin=null - then: CONST String type=kotlin.String value="OK" - BRANCH - if: CONST Boolean type=kotlin.Boolean value=true - then: CONST String type=kotlin.String value="Fail" -FILE fqName:foo.bar.some.additional.files fileName:/SomeFile.kt diff --git a/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.txt b/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.txt deleted file mode 100644 index f3140ec..0000000 --- a/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.fir.txt +++ /dev/null @@ -1,39 +0,0 @@ -FILE: reflect_test.kt - package foo.bar - - public final annotation class Test : R|kotlin/Annotation| { - public constructor(): R|foo/bar/Test| { - super() - } - - } - @R|arrow/meta/samples/Reflect|() public final data class Sample : R|kotlin/Any| { - public constructor(name: R|kotlin/String|, age: R|kotlin/Int|): R|foo/bar/Sample| { - super() - } - - public final val name: R|kotlin/String| = R|/name| - public get(): R|kotlin/String| - - public final val age: R|kotlin/Int| = R|/age| - public get(): R|kotlin/Int| - - public final operator fun component1(): R|kotlin/String| - - public final operator fun component2(): R|kotlin/Int| - - public final fun copy(name: R|kotlin/String| = this@R|foo/bar/Sample|.R|foo/bar/Sample.name|, age: R|kotlin/Int| = this@R|foo/bar/Sample|.R|foo/bar/Sample.age|): R|foo/bar/Sample| - - } - public final fun box(): R|kotlin/String| { - lval x: R|kotlin/reflect/KClass| = @R|arrow/meta/samples/Reflect|() (Q|foo/bar/Sample|) - ^box when () { - (R|/x| is R|arrow/meta/samples/CompileTimeReflected<*>|) -> { - String(OK) - } - else -> { - String(Fail) - } - } - - } diff --git a/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.kt b/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.kt deleted file mode 100644 index 6cffb32..0000000 --- a/arrow-reflect-compiler-plugin/src/testData/box/reflect_test.kt +++ /dev/null @@ -1,19 +0,0 @@ -package foo.bar - -import arrow.meta.samples.Reflect -import arrow.meta.samples.CompileTimeReflected -import kotlin.reflect.KClass - -annotation class Test - -@Reflect -data class Sample(val name: String, val age: Int) - -fun box(): String { - val x = @Reflect Sample::class - return if (x is CompileTimeReflected<*>) { - "OK" - } else { - "Fail" - } -} diff --git a/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.fir.txt b/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.fir.txt new file mode 100644 index 0000000..70288e4 --- /dev/null +++ b/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.fir.txt @@ -0,0 +1,16 @@ +FILE: reflect_test.kt + package foo.bar + + @R|arrow/meta/samples/Reflect|() public final data class Sample : R|kotlin/Any| { + public constructor(foo: R|kotlin/Int|): R|foo/bar/Sample| { + super() + } + + public final val foo: R|kotlin/Int| = R|/foo| + public get(): R|kotlin/Int| + + public final operator fun component1(): R|kotlin/Int| + + public final fun copy(foo: R|kotlin/Int| = this@R|foo/bar/Sample|.R|foo/bar/Sample.foo|): R|foo/bar/Sample| + + } diff --git a/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.kt b/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.kt new file mode 100644 index 0000000..42019af --- /dev/null +++ b/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.kt @@ -0,0 +1,6 @@ +package foo.bar + +import arrow.meta.samples.Reflect + +@Reflect +data class Sample(val foo: Int) diff --git a/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/BoxTestGenerated.java b/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/BoxTestGenerated.java index c96350e..c5e3cb9 100644 --- a/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/BoxTestGenerated.java +++ b/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/BoxTestGenerated.java @@ -40,12 +40,6 @@ public void testProduct_test_expected() throws Exception { runTest("src/testData/box/product_test_expected.kt"); } - @Test - @TestMetadata("reflect_test.kt") - public void testReflect_test() throws Exception { - runTest("src/testData/box/reflect_test.kt"); - } - @Test @TestMetadata("sample_test.kt") public void testSample_test() throws Exception { diff --git a/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java b/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java index d516e5e..4142dbc 100644 --- a/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java +++ b/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java @@ -33,6 +33,12 @@ public void testPure_test() throws Exception { runTest("src/testData/diagnostics/pure_test.kt"); } + @Test + @TestMetadata("reflect_test.kt") + public void testReflect_test() throws Exception { + runTest("src/testData/diagnostics/reflect_test.kt"); + } + @Test @TestMetadata("sample_test.kt") public void testSample_test() throws Exception { From ab0019cff9a3ea67c71b130d5ecebaeab1b9f1a5 Mon Sep 17 00:00:00 2001 From: raulraja Date: Sun, 1 Jan 2023 19:57:06 +0100 Subject: [PATCH 3/8] Add immutable example, remove Reflect example --- arrow-reflect-annotations/build.gradle.kts | 1 + .../src/main/kotlin/MetaModule.kt | 2 +- .../src/main/kotlin/arrow/meta/Diagnostics.kt | 1 + .../kotlin/arrow/meta/samples/Immutable.kt | 78 ++++ .../main/kotlin/arrow/meta/samples/Reflect.kt | 408 ------------------ .../diagnostics/immutable_test.fir.txt | 18 + .../testData/diagnostics/immutable_test.kt | 12 + .../testData/diagnostics/reflect_test.fir.txt | 16 - .../src/testData/diagnostics/reflect_test.kt | 6 - .../runners/DiagnosticTestGenerated.java | 12 +- 10 files changed, 117 insertions(+), 437 deletions(-) create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Immutable.kt delete mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt create mode 100644 arrow-reflect-compiler-plugin/src/testData/diagnostics/immutable_test.fir.txt create mode 100644 arrow-reflect-compiler-plugin/src/testData/diagnostics/immutable_test.kt delete mode 100644 arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.fir.txt delete mode 100644 arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.kt diff --git a/arrow-reflect-annotations/build.gradle.kts b/arrow-reflect-annotations/build.gradle.kts index f209f66..d8465e9 100644 --- a/arrow-reflect-annotations/build.gradle.kts +++ b/arrow-reflect-annotations/build.gradle.kts @@ -49,4 +49,5 @@ sourceSets { dependencies { compileOnly(libs.kotlin.compiler) kotlinCompilerPluginClasspath(libs.kotlin.compiler) + implementation("com.lilittlecat:chatgpt:0.1.0") } diff --git a/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt b/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt index f98c3ca..d872a73 100644 --- a/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt +++ b/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt @@ -9,6 +9,6 @@ interface MetaModule: Module { val log: Log val decorator: Decorator val pure: Pure - val reflect: Reflect + val immutable: Immutable } diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Diagnostics.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Diagnostics.kt index 74342aa..cc8b67b 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Diagnostics.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Diagnostics.kt @@ -12,6 +12,7 @@ abstract class Diagnostics(val head: KtDiagnosticFactory1, vararg factor interface Error { fun error1(): DiagnosticFactory1DelegateProvider = error1() + fun warning1(): DiagnosticFactory1DelegateProvider = warning1() } init { diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Immutable.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Immutable.kt new file mode 100644 index 0000000..2bd981a --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Immutable.kt @@ -0,0 +1,78 @@ +package arrow.meta.samples + +import arrow.meta.Diagnostics +import arrow.meta.FirMetaCheckerContext +import arrow.meta.Meta +import arrow.meta.samples.ImmutableErrors.FoundMutableIterable +import arrow.meta.samples.ImmutableErrors.FoundMutableKProperty +import arrow.meta.samples.ImmutableErrors.FoundMutableVar +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirProperty +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol +import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.visitors.FirVisitor +import kotlin.reflect.KType +import kotlin.reflect.typeOf + +object ImmutableErrors : Diagnostics.Error { + val FoundMutableVar by error1() + val FoundMutableKProperty by error1() + val FoundMutableIterable by error1() +} + +@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.FILE) +@Retention(AnnotationRetention.SOURCE) +@Meta +annotation class Immutable { + companion object : Meta.Checker.Declaration, + Diagnostics(FoundMutableVar, FoundMutableKProperty, FoundMutableIterable) { + + override fun FirMetaCheckerContext.check(declaration: FirDeclaration) { + declaration.accept(object : FirVisitor() { + override fun visitElement(element: FirElement, data: Unit) { + element.acceptChildren(this, data) + } + + override fun visitProperty(property: FirProperty, data: Unit) { + if (property.isVar) { + property.report(FoundMutableVar, "mutable vars are forbidden in `${Immutable::class.java.simpleName}` container") + } + visitElement(property, data) + } + + override fun visitFunctionCall(functionCall: FirFunctionCall, data: Unit) { + val resolvedType = functionCall.toResolvedCallableSymbol()?.resolvedReturnType + if (resolvedType != null) { + if (isMutableKProperty(resolvedType)) { + functionCall.report( + FoundMutableKProperty, + "mutable KProperties are forbidden in `${Immutable::class.java.simpleName}` container" + ) + } + if (extends(typeOf>(), resolvedType)) { + functionCall.report( + FoundMutableIterable, + "mutable iterables are forbidden in `${Immutable::class.java.simpleName}` container" + ) + } + } + super.visitFunctionCall(functionCall, data) + } + + }, Unit) + } + + private fun FirMetaCheckerContext.extends(type: KType, coneType: ConeKotlinType): Boolean { + val rawType = coneType.renderReadableWithFqNames().replace("/", ".").substringBefore("<") + val selectedType = type.toString().substringBefore("<") + return rawType == selectedType || coneType.toRegularClassSymbol(session)?.resolvedSuperTypes?.any { + extends(type, it) + } == true + } + + private fun FirMetaCheckerContext.isMutableKProperty(coneType: ConeKotlinType) = + coneType.isKMutableProperty(session) + } +} diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt deleted file mode 100644 index c9fb31a..0000000 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/Reflect.kt +++ /dev/null @@ -1,408 +0,0 @@ -package arrow.meta.samples - -import arrow.meta.FirMetaCheckerContext -import arrow.meta.FirMetaContext -import arrow.meta.FirMetaMemberGenerationContext -import arrow.meta.Meta -import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.descriptors.Visibilities -import org.jetbrains.kotlin.descriptors.Visibility -import org.jetbrains.kotlin.fir.FirAnnotationContainer -import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.declarations.utils.* -import org.jetbrains.kotlin.fir.expressions.FirGetClassCall -import org.jetbrains.kotlin.fir.expressions.FirStatement -import org.jetbrains.kotlin.fir.resolve.defaultType -import org.jetbrains.kotlin.fir.resolve.fqName -import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider -import org.jetbrains.kotlin.fir.symbols.SymbolInternals -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.types.* -import org.jetbrains.kotlin.fir.visitors.FirTransformer -import org.jetbrains.kotlin.fir.visitors.FirVisitor -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.types.Variance -import kotlin.reflect.* - - -@Target(AnnotationTarget.EXPRESSION, AnnotationTarget.CLASS) -@Retention(AnnotationRetention.SOURCE) -@Meta -annotation class Reflect { - companion object : - //Meta.FrontendTransformer.RegularClass, - Meta.FrontendTransformer.GetClassCall, - Meta.Generate.Members.NestedClasses { - - override fun FirMetaMemberGenerationContext.nestedClasses(firClass: FirClassSymbol<*>): Set { - println("call to nestedClasses: ${firClass.classId}, annotations: ${firClass.annotations.joinToString()}") - return emptySet() - } - - override fun FirMetaMemberGenerationContext.nestedClasses(classId: ClassId): List { - return emptyList() - } - - - -// override fun FirMetaMemberGenerationContext.nestedClasses(firClass: FirClassSymbol<*>): Set { -// val isReflected = -// firClass.annotations.any { it.annotationTypeRef.source?.text == Reflect::class.java.simpleName } -// return if (isReflected) { -// setOf(Name.identifier("Reflected")) -// } else emptySet() -// } - -// @OptIn(SymbolInternals::class) -// override fun FirMetaMemberGenerationContext.nestedClasses(classId: ClassId): List = -// classId.parentClassId?.let { parentId -> -// val parent = session.symbolProvider.getClassLikeSymbolByClassId(parentId)?.fir as? FirRegularClass -// parent?.declarations?.filterIsInstance()?.filter { classId == it.classId } ?: emptyList() -// } ?: emptyList() - - override fun FirMetaCheckerContext.getClassCall(getClassCall: FirGetClassCall): FirStatement { - return "${+getClassCall.argument.typeRef}${Reflect::class.java.simpleName}()".call - } - -// override fun FirMetaCheckerContext.regularClass(regularClass: FirRegularClass): FirStatement { -// val kClassSource = kClass(regularClass) -// return regularClass.addDeclarations(compile(kClassSource)) -// } - } -} - -interface CompileTimeReflected : KClass - -@OptIn(SymbolInternals::class) -fun FirMetaContext.kClass(firClass: FirRegularClass): String { - val supertypes = firClass.superTypeRefs - val constructors = firClass.indexedDeclarations() - val properties = firClass.indexedDeclarations() - val functions = firClass.indexedDeclarations() - val nestedClasses = firClass.indexedDeclarations() - val sealedSubclasses = when { - firClass.isSealed -> firClass - .getSealedClassInheritors(session) - .mapNotNull { session.symbolProvider.getClassLikeSymbolByClassId(it)?.fir } - .filterIsInstance() - - else -> emptyList() - } - //language=kotlin - return """ - import kotlin.reflect.* - - class Reflected : arrow.meta.samples.CompileTimeReflected<${firClass.classId.asFqNameString()}> { - - // constructors - ${constructors.joinToString("\n") { (n, it) -> kFunction(n, it) }} - - // properties - ${properties.joinToString("\n") { (_, it) -> kProperty(firClass, it) }} - - //functions - ${functions.joinToString("\n") { (n, it) -> kFunction(n, it) }} - - //nested classes - ${nestedClasses.joinToString("\n") { (_, it) -> kClass(it) }} - - //sealed subclases - ${sealedSubclasses.joinToString("\n") { kClass(it) }} - - - override val annotations: List by lazy { ${reflectedAnnotations(firClass)} } - - override val constructors: Collection> by lazy { - listOf(${constructors.joinToString { (n, it) -> "${kFunctionName(n, it)}()" }}) - } - - override val members: Collection> by lazy { - listOf(${properties.joinToString { (_, it) -> "${+it.name}()" }}) + - listOf(${functions.joinToString { (n, it) -> "${kFunctionName(n, it)}()" }}) - } - - - override val nestedClasses: Collection> by lazy { - listOf(${nestedClasses.joinToString { (_, it) -> "${+it.name}()" }}) - } - - override val sealedSubclasses: List> by lazy { - listOf(${sealedSubclasses.joinToString { "${+it.name}()" }}) - } - - - override val supertypes: List by lazy { - listOf(${supertypes.joinToString { kType(it) }}) - } - - - override val isAbstract: Boolean by lazy { ${firClass.isAbstract} } - override val isCompanion: Boolean by lazy { ${firClass.isCompanion} } - override val isData: Boolean by lazy { ${firClass.isData} } - override val isFinal: Boolean by lazy { ${firClass.isFinal} } - override val isFun: Boolean by lazy { ${firClass.isFun} } - override val isInner: Boolean by lazy { ${firClass.isInner} } - override val isOpen: Boolean by lazy { ${firClass.isOpen} } - override val isSealed: Boolean by lazy { ${firClass.isSealed} } - override val isValue: Boolean by lazy { ${firClass.isInline} } - override val objectInstance: ${firClass.classId.asFqNameString()}? by lazy { - ${if (firClass.classKind == ClassKind.OBJECT) firClass.classId.asFqNameString() else null} - } - override val qualifiedName: String by lazy { "${firClass.classId.asFqNameString()}" } - override val simpleName: String by lazy { "${firClass.classId.shortClassName}" } - override val typeParameters: List by lazy { - listOf(${firClass.typeParameters.joinToString { kTypeParameter(it.symbol.fir) }}) - } - override val visibility: KVisibility? by lazy { ${kVisibility(firClass.visibility)} } - - override fun equals(other: Any?): Boolean = - TODO() //${firClass.classId.asFqNameString()}::class.equals(other) - - override fun hashCode(): Int = - TODO() //${firClass.classId.asFqNameString()}::class.hashCode() - - override fun isInstance(value: Any?): Boolean = - value is ${firClass.classId.asFqNameString()} - } - """ -} - -private inline fun FirRegularClass.indexedDeclarations(): List> = - declarations.filterIsInstance().filter { !it.isSynthetic }.mapIndexed { index, t -> index to t } - - -private fun FirMetaContext.reflectedAnnotations(container: FirAnnotationContainer): String = - """listOf(${ - container.annotations.mapNotNull { ann -> ann.fqName(session)?.let { ann to it.asString() } } - .joinToString { (ann, fqName) -> "$fqName(${ann.argumentMapping.mapping.entries.joinToString { (k, v) -> "${+k} = ${+v}" }})" } - })""" - -@OptIn(SymbolInternals::class) -private fun FirMetaContext.kFunction(n: Int, fn: FirFunction): String = - source( - """ -inner class ${kFunctionName(n, fn)} : KFunction<${+fn.returnTypeRef}> { - override val annotations: List by lazy { ${reflectedAnnotations(fn)} } - override val isAbstract: Boolean by lazy { ${fn.isAbstract} } - override val isFinal: Boolean by lazy { ${fn.isFinal} } - override val isOpen: Boolean by lazy { ${fn.isOpen} } - override val name: String by lazy { "${name(fn)}" } - override val parameters: List by lazy { - listOf(${fn.valueParameters.mapIndexed { i, p -> kParameter(i, p) }.joinToString()}) - } - override val returnType: KType by lazy { ${kType(fn.returnTypeRef)} } - override val typeParameters: List by lazy { - listOf(${fn.typeParameters.joinToString { kTypeParameter(it.symbol.fir) }}) - } - override val visibility: KVisibility? by lazy { ${kVisibility(fn.visibility)} } - - override fun call(vararg args: Any?): ${+fn.returnTypeRef} { - TODO("Not yet implemented") - } - - override fun callBy(args: Map): ${+fn.returnTypeRef} { - TODO("Not yet implemented") - } - - override val isExternal: Boolean by lazy { ${fn.isExternal} } - override val isInfix: Boolean by lazy { ${fn.isInfix} } - override val isInline: Boolean by lazy { ${fn.isInline} } - override val isOperator: Boolean by lazy { ${fn.isOperator} } - override val isSuspend: Boolean by lazy { ${fn.isSuspend} } -} -""" - ) - -private fun FirMetaContext.kFunctionName(n: Int, fn: FirFunction): String = - when (fn) { - is FirSimpleFunction -> +fn.name - is FirConstructor -> "constructor$n" - else -> error("expected FirSimpleFunction or FirConstructor") - } - -private fun name(member: FirMemberDeclaration): String = - when (member) { - is FirSimpleFunction -> member.name.asString() - is FirConstructor -> Name.special("").asString() - else -> Name.special("").asString() - } - -@OptIn(SymbolInternals::class) -private fun FirMetaContext.kType(type: FirTypeRef): String = - source( - """ - object : KType { - override val annotations: List by lazy { ${reflectedAnnotations(type)} } - override val arguments: List by lazy { - listOf(${type.extractTypeArguments().joinToString { kTypeProjection(it) }}) - } - override val classifier: KClassifier? by lazy { - null //${ - type.coneType.toRegularClassSymbol(session)?.fir?.classId?.asFqNameString()?.let { "$it::class" } ?: "null" - } - } - override val isMarkedNullable: Boolean by lazy { ${type.isMarkedNullable} } - } -""" - ) - -internal class ReflectTypeProjectionWithVariance( - override val source: KtSourceElement?, - override var typeRef: FirTypeRef, - override val variance: Variance, -) : FirTypeProjectionWithVariance() { - override fun acceptChildren(visitor: FirVisitor, data: D) { - typeRef.accept(visitor, data) - } - - override fun transformChildren(transformer: FirTransformer, data: D): ReflectTypeProjectionWithVariance { - typeRef = typeRef.transform(transformer, data) - return this - } -} - -fun ProjectionKind.toVariance(): Variance = - when (this) { - ProjectionKind.STAR -> Variance.INVARIANT - ProjectionKind.IN -> Variance.IN_VARIANCE - ProjectionKind.OUT -> Variance.OUT_VARIANCE - ProjectionKind.INVARIANT -> Variance.INVARIANT - } - -fun FirTypeRef.extractTypeArguments(): List { - return when (this) { - is FirResolvedTypeRef -> type.typeArguments.mapNotNull { - val resolved = it.type?.toFirResolvedTypeRef() - if (resolved != null) ReflectTypeProjectionWithVariance(null, resolved, it.kind.toVariance()) - else null - } - - is FirUserTypeRef -> qualifier.flatMap { it.typeArgumentList.typeArguments.map { it } } - else -> emptyList() - } -} - -private fun FirMetaContext.kProperty(owner: FirRegularClass, prop: FirProperty): String = - source( - """ - inner class ${+prop.name} : KProperty1<${owner.renderType()}, ${+prop.returnTypeRef}> { - override val annotations: List by lazy { - listOf() - } - override val isAbstract: Boolean by lazy { ${prop.isAbstract} } - override val isFinal: Boolean by lazy { ${prop.isFinal} } - override val isOpen: Boolean by lazy { ${prop.isOpen} } - override val isSuspend: Boolean by lazy { ${prop.isSuspend} } - override val name: String by lazy { "${+prop.name}" } - override val parameters: List by lazy { ${kParameters(prop)} } - override val returnType: KType by lazy { ${kType(prop.returnTypeRef)} } - override val typeParameters: List by lazy { listOf(${ - prop.typeParameters.joinToString { - kTypeParameter( - it - ) - } - }) } - override val visibility: KVisibility? by lazy { ${kVisibility(prop.visibility)} } - - override fun call(vararg args: Any?): ${+prop.returnTypeRef} { - TODO("Not yet implemented") - } - - override fun callBy(args: Map): ${+prop.returnTypeRef} { - TODO("Not yet implemented") - } - - override val isConst: Boolean by lazy { ${prop.isConst} } - override val isLateinit: Boolean by lazy { ${prop.isLateInit} } - override val getter: KProperty1.Getter<${owner.renderType()}, ${+prop.returnTypeRef}> by lazy { - TODO() - } - - override fun get(receiver: ${owner.renderType()}): ${+prop.returnTypeRef} { - TODO("Not yet implemented") - } - - override fun getDelegate(receiver: ${owner.renderType()}): Any? { - TODO("Not yet implemented") - } - - override fun invoke(p1: ${owner.renderType()}): ${+prop.returnTypeRef} { - TODO("Not yet implemented") - } - - } -""" - ) - -private fun FirRegularClass.renderType(): String = - defaultType().type.renderReadableWithFqNames().replace("/", ".") - - -private fun FirMetaContext.kTypeParameter(type: FirTypeParameter): String = - source( - """ -object : KTypeParameter { - override val annotations: List by lazy { ${reflectedAnnotations(type)} } - override val isReified: Boolean by lazy { ${type.isReified} } - override val name: String by lazy { "${type.name}" } - override val upperBounds: List by lazy { - listOf(${type.bounds.joinToString { kType(it) }}) - } - override val variance: KVariance by lazy { ${kVariance(type.variance)} } -} -""" - ) - -private fun kVariance(variance: Variance): String = - when (variance) { - Variance.INVARIANT -> "Variance.INVARIANT" - Variance.IN_VARIANCE -> "KVariance.IN" - Variance.OUT_VARIANCE -> "KVariance.OUT" - } - -private fun kVisibility(visibility: Visibility): String = - when (visibility) { - Visibilities.Public -> "KVisibility.PUBLIC" - Visibilities.Protected -> "KVisibility.PROTECTED" - Visibilities.Internal -> "KVisibility.INTERNAL" - Visibilities.Private -> "KVisibility.PRIVATE" - else -> "" + - "KVisibility.PUBLIC" - } - -private fun FirMetaContext.kParameters(fn: FirMemberDeclaration): String = - if (fn is FirFunction) - """listOf(${fn.valueParameters.mapIndexed { n, p -> kParameter(n, p) }.joinToString()})""" - else "emptyList()" - -private fun FirMetaContext.kParameter(n: Int, param: FirValueParameter): String = - source( - """ - object : KParameter { - override val annotations: List by lazy { ${reflectedAnnotations(param)} } - override val index: Int by lazy { $n } - override val isOptional: Boolean by lazy { ${param.defaultValue != null} } - override val isVararg: Boolean by lazy { ${param.isVararg} } - override val kind: KParameter.Kind by lazy { TODO() } - override val name: String? by lazy { "${param.name}" } - override val type: KType by lazy { ${kType(param.returnTypeRef)} } - } -""" - ) - -private fun FirMetaContext.kTypeProjection(projection: FirTypeProjection): String = - when (projection) { - is FirStarProjection -> "KTypeProjection.STAR" - is FirTypeProjectionWithVariance -> source( - """ - KTypeProjection(${kVariance(projection.variance)}, ${kType(projection.typeRef)}) - """ - ) - - else -> error("expected FirStarProjection or FirTypeProjectionWithVariance") - } - - diff --git a/arrow-reflect-compiler-plugin/src/testData/diagnostics/immutable_test.fir.txt b/arrow-reflect-compiler-plugin/src/testData/diagnostics/immutable_test.fir.txt new file mode 100644 index 0000000..888c3ab --- /dev/null +++ b/arrow-reflect-compiler-plugin/src/testData/diagnostics/immutable_test.fir.txt @@ -0,0 +1,18 @@ +FILE: immutable_test.kt + @FILE:R|arrow/meta/samples/Immutable|() + package foo.bar + + public final class Sample : R|kotlin/Any| { + public constructor(foo: R|kotlin/Int|): R|foo/bar/Sample| { + super() + } + + public final var foo: R|kotlin/Int| = R|/foo| + public get(): R|kotlin/Int| + public set(value: R|kotlin/Int|): R|kotlin/Unit| + + } + public final fun foo(): R|kotlin/Unit| { + lvar x: R|kotlin/Int| = Int(0) + lval l: R|kotlin/collections/MutableList| = R|kotlin/collections/mutableListOf|() + } diff --git a/arrow-reflect-compiler-plugin/src/testData/diagnostics/immutable_test.kt b/arrow-reflect-compiler-plugin/src/testData/diagnostics/immutable_test.kt new file mode 100644 index 0000000..19dada8 --- /dev/null +++ b/arrow-reflect-compiler-plugin/src/testData/diagnostics/immutable_test.kt @@ -0,0 +1,12 @@ +@file:Immutable + +package foo.bar + +import arrow.meta.samples.Immutable + +class Sample(var foo: Int) + +fun foo() { + var x = 0 + val l = mutableListOf() +} diff --git a/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.fir.txt b/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.fir.txt deleted file mode 100644 index 70288e4..0000000 --- a/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.fir.txt +++ /dev/null @@ -1,16 +0,0 @@ -FILE: reflect_test.kt - package foo.bar - - @R|arrow/meta/samples/Reflect|() public final data class Sample : R|kotlin/Any| { - public constructor(foo: R|kotlin/Int|): R|foo/bar/Sample| { - super() - } - - public final val foo: R|kotlin/Int| = R|/foo| - public get(): R|kotlin/Int| - - public final operator fun component1(): R|kotlin/Int| - - public final fun copy(foo: R|kotlin/Int| = this@R|foo/bar/Sample|.R|foo/bar/Sample.foo|): R|foo/bar/Sample| - - } diff --git a/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.kt b/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.kt deleted file mode 100644 index 42019af..0000000 --- a/arrow-reflect-compiler-plugin/src/testData/diagnostics/reflect_test.kt +++ /dev/null @@ -1,6 +0,0 @@ -package foo.bar - -import arrow.meta.samples.Reflect - -@Reflect -data class Sample(val foo: Int) diff --git a/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java b/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java index 4142dbc..a50cc34 100644 --- a/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java +++ b/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java @@ -21,6 +21,12 @@ public void testAllFilesPresentInDiagnostics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("src/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test + @TestMetadata("immutable_test.kt") + public void testImmutable_test() throws Exception { + runTest("src/testData/diagnostics/immutable_test.kt"); + } + @Test @TestMetadata("log_test.kt") public void testLog_test() throws Exception { @@ -33,12 +39,6 @@ public void testPure_test() throws Exception { runTest("src/testData/diagnostics/pure_test.kt"); } - @Test - @TestMetadata("reflect_test.kt") - public void testReflect_test() throws Exception { - runTest("src/testData/diagnostics/reflect_test.kt"); - } - @Test @TestMetadata("sample_test.kt") public void testSample_test() throws Exception { From c00389a8e1c06c80ab7952709f88c5d2843e3adc Mon Sep 17 00:00:00 2001 From: raulraja Date: Sun, 1 Jan 2023 19:59:27 +0100 Subject: [PATCH 4/8] remove chatgpt demo dep --- arrow-reflect-annotations/build.gradle.kts | 1 - 1 file changed, 1 deletion(-) diff --git a/arrow-reflect-annotations/build.gradle.kts b/arrow-reflect-annotations/build.gradle.kts index d8465e9..f209f66 100644 --- a/arrow-reflect-annotations/build.gradle.kts +++ b/arrow-reflect-annotations/build.gradle.kts @@ -49,5 +49,4 @@ sourceSets { dependencies { compileOnly(libs.kotlin.compiler) kotlinCompilerPluginClasspath(libs.kotlin.compiler) - implementation("com.lilittlecat:chatgpt:0.1.0") } From dd12be2d29c43546d57d7a6a1b9535276793edeb Mon Sep 17 00:00:00 2001 From: raulraja Date: Wed, 4 Jan 2023 00:03:34 +0100 Subject: [PATCH 5/8] disallow lambda capture, prevents raise from leaking --- .../src/main/kotlin/MetaModule.kt | 1 + .../meta/samples/DisallowLambdaCapture.kt | 57 +++++++++++++++++++ .../FirMetaAdditionalCheckersExtension.kt | 51 +++++++++++------ .../testData/diagnostics/capture_test.fir.txt | 25 ++++++++ .../src/testData/diagnostics/capture_test.kt | 22 +++++++ .../runners/DiagnosticTestGenerated.java | 6 ++ sandbox/src/main/kotlin/Sample.kt | 25 +++++--- 7 files changed, 163 insertions(+), 24 deletions(-) create mode 100644 arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt create mode 100644 arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.fir.txt create mode 100644 arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.kt diff --git a/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt b/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt index d872a73..f368d04 100644 --- a/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt +++ b/arrow-reflect-annotations/src/main/kotlin/MetaModule.kt @@ -10,5 +10,6 @@ interface MetaModule: Module { val decorator: Decorator val pure: Pure val immutable: Immutable + val disallowLambdaCapture: DisallowLambdaCapture } diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt new file mode 100644 index 0000000..1ed015d --- /dev/null +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt @@ -0,0 +1,57 @@ +package arrow.meta.samples + +import arrow.meta.Diagnostics +import arrow.meta.FirMetaCheckerContext +import arrow.meta.Meta +import arrow.meta.samples.DisallowLambdaCaptureErrors.UnsafeCaptureDetected +import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction +import org.jetbrains.kotlin.fir.declarations.InlineStatus +import org.jetbrains.kotlin.fir.declarations.findArgumentByName +import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId +import org.jetbrains.kotlin.fir.expressions.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirConstExpression +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.ConstantValueKind + +object DisallowLambdaCaptureErrors : Diagnostics.Error { + val UnsafeCaptureDetected by error1() +} + +@Meta +@Target(AnnotationTarget.FUNCTION) +annotation class DisallowLambdaCapture(val msg: String = "") { + companion object : Meta.Checker.Expression, + Diagnostics(UnsafeCaptureDetected) { + + val annotation = DisallowLambdaCapture::class.java + + override fun FirMetaCheckerContext.check(expression: FirFunctionCall) { + val scope = scopeDeclarations.filterIsInstance().firstOrNull() + if (scope != null && scope.inlineStatus != InlineStatus.Inline) { + val nameArg = expression + .disallowLambdaCaptureAnnotation()?.findArgumentByName(Name.identifier(DisallowLambdaCapture::msg.name)) + val userMsg = + if (nameArg is FirConstExpression<*> && nameArg.kind == ConstantValueKind.String) nameArg.value as? String + else null + expression.report( + UnsafeCaptureDetected, + userMsg ?: "detected call to member @DisallowLambdaCapture `${+expression}` in non-inline anonymous function" + ) + } + } + + private fun FirFunctionCall.disallowLambdaCaptureAnnotation(): FirAnnotation? = + toResolvedCallableSymbol()?.fir?.getAnnotationByClassId( + ClassId( + FqName(annotation.`package`.name), + Name.identifier(annotation.simpleName) + ) + ) + } +} + + diff --git a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/checkers/FirMetaAdditionalCheckersExtension.kt b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/checkers/FirMetaAdditionalCheckersExtension.kt index d0824ec..b280c8f 100644 --- a/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/checkers/FirMetaAdditionalCheckersExtension.kt +++ b/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin/fir/checkers/FirMetaAdditionalCheckersExtension.kt @@ -58,25 +58,42 @@ class FirMetaAdditionalCheckersExtension( } private inline fun invokeChecker( - superType: KClass<*>, - element: E, - session: FirSession, - context: CheckerContext, - reporter: DiagnosticReporter + superType: KClass<*>, + element: E, + session: FirSession, + context: CheckerContext, + reporter: DiagnosticReporter ) { - if (element is FirAnnotationContainer && element.isMetaAnnotated(session)) { - val annotations = element.metaAnnotations(session) - val metaContext = FirMetaCheckerContext(templateCompiler, session, context, reporter) - invokeMeta( - false, - metaContext, - annotations, - superType = superType, - methodName = "check", - element - ) - } + if ((element is FirAnnotationContainer && element.isMetaAnnotated(session)) || (element is FirFunctionCall && element.isCallToAnnotatedFunction( + session + )) + ) { + val annotations = + when (element) { + is FirFunctionCall -> + element.metaAnnotations(session) + element.toResolvedCallableSymbol()?.fir?.metaAnnotations( + session + ).orEmpty() + is FirAnnotationContainer -> element.metaAnnotations(session) + else -> emptyList() + } + val metaContext = FirMetaCheckerContext(templateCompiler, session, context, reporter) + invokeMeta( + false, + metaContext, + annotations, + superType = superType, + methodName = "check", + element + ) } + } + + private inline fun E.isCallToAnnotatedFunction( + session: FirSession + ): Boolean { + return toResolvedCallableSymbol()?.fir?.isMetaAnnotated(session) == true + } override val typeCheckers: TypeCheckers get() = super.typeCheckers diff --git a/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.fir.txt b/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.fir.txt new file mode 100644 index 0000000..58f720b --- /dev/null +++ b/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.fir.txt @@ -0,0 +1,25 @@ +FILE: capture_test.kt + package foo.bar + + public abstract interface Raise : R|kotlin/Any| { + @R|arrow/meta/samples/DisallowLambdaCapture|(msg = String(It's unsafe to capture `raise` inside non-inline anonymous functions)) public abstract fun raise(e: R|E|): R|kotlin/Nothing| + + } + context(R|foo/bar/Raise|) + public final fun shouldNotCature(): R|() -> kotlin/Unit| { + ^shouldNotCature fun (): R|kotlin/Unit| { + this@R|foo/bar/shouldNotCature|.R|SubstitutionOverride|(String(boom)) + } + + } + context(R|foo/bar/Raise|) + public final fun inlineCaptureOk(): R|kotlin/Unit| { + R|kotlin/collections/listOf|(vararg(Int(1), Int(2), Int(3))).R|kotlin/collections/map|( = map@fun (it: R|kotlin/Int|): R|kotlin/Nothing| { + this@R|foo/bar/inlineCaptureOk|.R|SubstitutionOverride|(String(boom)) + } + ) + } + context(R|foo/bar/Raise|) + public final fun ok(): R|kotlin/Unit| { + this@R|foo/bar/ok|.R|SubstitutionOverride|(String(boom)) + } diff --git a/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.kt b/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.kt new file mode 100644 index 0000000..db1c110 --- /dev/null +++ b/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.kt @@ -0,0 +1,22 @@ +package foo.bar + +import arrow.meta.samples.DisallowLambdaCapture + +interface Raise { + @DisallowLambdaCapture("It's unsafe to capture `raise` inside non-inline anonymous functions") fun raise(e: E): Nothing +} + +context(Raise) +fun shouldNotCature(): () -> Unit { + return { raise("boom") } +} + +context(Raise) +fun inlineCaptureOk(): Unit { + listOf(1, 2, 3).map { raise("boom") } +} + +context(Raise) +fun ok(): Unit { + raise("boom") +} diff --git a/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java b/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java index a50cc34..a84ba2b 100644 --- a/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java +++ b/arrow-reflect-compiler-plugin/src/testGenerated/arrow/reflect/compiler/plugin/runners/DiagnosticTestGenerated.java @@ -21,6 +21,12 @@ public void testAllFilesPresentInDiagnostics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("src/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test + @TestMetadata("capture_test.kt") + public void testCapture_test() throws Exception { + runTest("src/testData/diagnostics/capture_test.kt"); + } + @Test @TestMetadata("immutable_test.kt") public void testImmutable_test() throws Exception { diff --git a/sandbox/src/main/kotlin/Sample.kt b/sandbox/src/main/kotlin/Sample.kt index feae105..d00ba0c 100644 --- a/sandbox/src/main/kotlin/Sample.kt +++ b/sandbox/src/main/kotlin/Sample.kt @@ -1,12 +1,23 @@ -package example +package foo.bar -import arrow.meta.samples.Product +import arrow.meta.samples.DisallowLambdaCapture -@Product -data class Sample(val name: String, val age: Int) +interface Raise { + @DisallowLambdaCapture("It's unsafe to capture `raise` inside non-inline anonymous functions") + fun raise(e: E): Nothing +} + +context(Raise) +fun shouldNotCature(): () -> Unit { + return { raise("boom") } +} +context(Raise) +fun inlineCaptureOk(): Unit { + listOf(1, 2, 3).map { raise("boom") } +} -fun main() { - val properties = Sample("j", 12).product() - println(properties) +context(Raise) +fun ok(): Unit { + raise("boom") } From fa18304ffbb944e7c7715e6f95fab8cc31489087 Mon Sep 17 00:00:00 2001 From: raulraja Date: Wed, 4 Jan 2023 13:14:14 +0100 Subject: [PATCH 6/8] lookup all parents that are anonymous functions to avoid leaks --- .../meta/samples/DisallowLambdaCapture.kt | 71 ++++++++++++++++--- .../testData/diagnostics/capture_test.fir.txt | 16 ++++- .../src/testData/diagnostics/capture_test.kt | 7 +- sandbox/src/main/kotlin/Sample.kt | 19 ++++- 4 files changed, 96 insertions(+), 17 deletions(-) diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt index 1ed015d..ab25b07 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt @@ -16,6 +16,9 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.ConstantValueKind +import kotlin.contracts.ExperimentalContracts +import kotlin.contracts.InvocationKind +import kotlin.contracts.contract object DisallowLambdaCaptureErrors : Diagnostics.Error { val UnsafeCaptureDetected by error1() @@ -30,17 +33,19 @@ annotation class DisallowLambdaCapture(val msg: String = "") { val annotation = DisallowLambdaCapture::class.java override fun FirMetaCheckerContext.check(expression: FirFunctionCall) { - val scope = scopeDeclarations.filterIsInstance().firstOrNull() - if (scope != null && scope.inlineStatus != InlineStatus.Inline) { - val nameArg = expression - .disallowLambdaCaptureAnnotation()?.findArgumentByName(Name.identifier(DisallowLambdaCapture::msg.name)) - val userMsg = - if (nameArg is FirConstExpression<*> && nameArg.kind == ConstantValueKind.String) nameArg.value as? String - else null - expression.report( - UnsafeCaptureDetected, - userMsg ?: "detected call to member @DisallowLambdaCapture `${+expression}` in non-inline anonymous function" - ) + val nameArg = expression + .disallowLambdaCaptureAnnotation()?.findArgumentByName(Name.identifier(DisallowLambdaCapture::msg.name)) + val userMsg = + if (nameArg is FirConstExpression<*> && nameArg.kind == ConstantValueKind.String) nameArg.value as? String + else null + scopeDeclarations.filterIsInstance().forEach { scope -> + if (scope != null && scope.inlineStatus != InlineStatus.Inline) { + expression.report( + UnsafeCaptureDetected, + userMsg + ?: "detected call to member @DisallowLambdaCapture `${+expression}` in non-inline anonymous function" + ) + } } } @@ -54,4 +59,48 @@ annotation class DisallowLambdaCapture(val msg: String = "") { } } +interface Raise { + @DisallowLambdaCapture("It's unsafe to capture `raise` inside non-inline anonymous functions") + fun raise(e: E): Nothing +} + +context(Raise) +fun shouldNotCature(): () -> Unit { + return { raise("boom") } +} + +context(Raise) +fun inlineCaptureOk(): Unit { + listOf(1, 2, 3).map { raise("boom") } +} + +@OptIn(ExperimentalContracts::class) +fun exactlyOne(f: () -> Unit): Unit { + contract { + callsInPlace(f, InvocationKind.EXACTLY_ONCE) + } +} + +@OptIn(ExperimentalContracts::class) +fun exactlyOnce(f: () -> Unit): Unit { + contract { + callsInPlace(f, InvocationKind.EXACTLY_ONCE) + } +} + +context(Raise) +fun ok(): () -> Unit = { + listOf(1).map { raise("boom") } +} + +fun main() { + val raise = object : Raise { + override fun raise(e: String): Nothing = TODO() + } + val leaked = raise.run { + ok() + } + leaked() +} + diff --git a/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.fir.txt b/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.fir.txt index 58f720b..1712eb1 100644 --- a/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.fir.txt +++ b/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.fir.txt @@ -6,9 +6,9 @@ FILE: capture_test.kt } context(R|foo/bar/Raise|) - public final fun shouldNotCature(): R|() -> kotlin/Unit| { - ^shouldNotCature fun (): R|kotlin/Unit| { - this@R|foo/bar/shouldNotCature|.R|SubstitutionOverride|(String(boom)) + public final fun shouldNotCapture(): R|() -> kotlin/Unit| { + ^shouldNotCapture fun (): R|kotlin/Unit| { + this@R|foo/bar/shouldNotCapture|.R|SubstitutionOverride|(String(boom)) } } @@ -20,6 +20,16 @@ FILE: capture_test.kt ) } context(R|foo/bar/Raise|) + public final fun leakedNotOk(): R|() -> kotlin/Unit| { + ^leakedNotOk fun (): R|kotlin/Unit| { + R|kotlin/collections/listOf|(vararg(Int(1), Int(2), Int(3))).R|kotlin/collections/map|( = map@fun (it: R|kotlin/Int|): R|kotlin/Nothing| { + this@R|foo/bar/leakedNotOk|.R|SubstitutionOverride|(String(boom)) + } + ) + } + + } + context(R|foo/bar/Raise|) public final fun ok(): R|kotlin/Unit| { this@R|foo/bar/ok|.R|SubstitutionOverride|(String(boom)) } diff --git a/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.kt b/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.kt index db1c110..39f69a8 100644 --- a/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.kt +++ b/arrow-reflect-compiler-plugin/src/testData/diagnostics/capture_test.kt @@ -7,7 +7,7 @@ interface Raise { } context(Raise) -fun shouldNotCature(): () -> Unit { +fun shouldNotCapture(): () -> Unit { return { raise("boom") } } @@ -16,6 +16,11 @@ fun inlineCaptureOk(): Unit { listOf(1, 2, 3).map { raise("boom") } } +context(Raise) +fun leakedNotOk(): () -> Unit = { + listOf(1, 2, 3).map { raise("boom") } +} + context(Raise) fun ok(): Unit { raise("boom") diff --git a/sandbox/src/main/kotlin/Sample.kt b/sandbox/src/main/kotlin/Sample.kt index d00ba0c..e8e3b08 100644 --- a/sandbox/src/main/kotlin/Sample.kt +++ b/sandbox/src/main/kotlin/Sample.kt @@ -1,6 +1,7 @@ package foo.bar import arrow.meta.samples.DisallowLambdaCapture +import kotlin.contracts.* interface Raise { @DisallowLambdaCapture("It's unsafe to capture `raise` inside non-inline anonymous functions") @@ -17,7 +18,21 @@ fun inlineCaptureOk(): Unit { listOf(1, 2, 3).map { raise("boom") } } +@OptIn(ExperimentalContracts::class) +fun exactlyOne(f: () -> Unit): Unit { + contract { + callsInPlace(f, InvocationKind.EXACTLY_ONCE) + } +} + +@OptIn(ExperimentalContracts::class) +fun exactlyOnce(f: () -> Unit): Unit { + contract { + callsInPlace(f, InvocationKind.EXACTLY_ONCE) + } +} + context(Raise) -fun ok(): Unit { - raise("boom") +fun ok(): () -> Unit = { + exactlyOnce { raise("boom") } } From d4cf1f3fc5a2ad49e3010aedc5ce3379282f4d09 Mon Sep 17 00:00:00 2001 From: raulraja Date: Wed, 4 Jan 2023 13:15:16 +0100 Subject: [PATCH 7/8] cleanup --- .../meta/samples/DisallowLambdaCapture.kt | 45 ------------------- 1 file changed, 45 deletions(-) diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt index ab25b07..02c419e 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt @@ -59,48 +59,3 @@ annotation class DisallowLambdaCapture(val msg: String = "") { } } -interface Raise { - @DisallowLambdaCapture("It's unsafe to capture `raise` inside non-inline anonymous functions") - fun raise(e: E): Nothing -} - -context(Raise) -fun shouldNotCature(): () -> Unit { - return { raise("boom") } -} - -context(Raise) -fun inlineCaptureOk(): Unit { - listOf(1, 2, 3).map { raise("boom") } -} - -@OptIn(ExperimentalContracts::class) -fun exactlyOne(f: () -> Unit): Unit { - contract { - callsInPlace(f, InvocationKind.EXACTLY_ONCE) - } -} - -@OptIn(ExperimentalContracts::class) -fun exactlyOnce(f: () -> Unit): Unit { - contract { - callsInPlace(f, InvocationKind.EXACTLY_ONCE) - } -} - -context(Raise) -fun ok(): () -> Unit = { - listOf(1).map { raise("boom") } -} - -fun main() { - val raise = object : Raise { - override fun raise(e: String): Nothing = TODO() - } - val leaked = raise.run { - ok() - } - leaked() -} - - From 60dcb5fa08521c1fd9c3a286d6b9436a1ad8fd93 Mon Sep 17 00:00:00 2001 From: raulraja Date: Fri, 6 Jan 2023 23:43:23 +0100 Subject: [PATCH 8/8] adapt API to latest compiler snapshot --- .../src/main/kotlin/arrow/meta/Meta.kt | 7 ++++--- .../arrow/meta/samples/DisallowLambdaCapture.kt | 13 ++++++------- sandbox/src/main/kotlin/Sample.kt | 2 +- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Meta.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Meta.kt index 15e8039..52cb7de 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Meta.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/Meta.kt @@ -2,6 +2,7 @@ package arrow.meta import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirLabel +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.contracts.* import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.* @@ -27,7 +28,7 @@ annotation class Meta { fun intercept(args: List, func: (List) -> Out): Out override fun FirMetaCheckerContext.functionCall(functionCall: FirFunctionCall): FirStatement { - val newCall = if (isDecorated(functionCall)) { + val newCall = if (session.isDecorated(functionCall)) { //language=kotlin val call: FirCall = decoratedCall(functionCall) call @@ -36,14 +37,14 @@ annotation class Meta { } @OptIn(SymbolInternals::class) - private fun isDecorated(newElement: FirFunctionCall): Boolean = + private fun FirSession.isDecorated(newElement: FirFunctionCall): Boolean = newElement.toResolvedCallableSymbol()?.fir?.annotations?.hasAnnotation( ClassId.topLevel( FqName( annotation.java.canonicalName ) ) - ) == true + , this) == true private fun FirMetaContext.decoratedCall( newElement: FirFunctionCall diff --git a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt index 02c419e..431f467 100644 --- a/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt +++ b/arrow-reflect-annotations/src/main/kotlin/arrow/meta/samples/DisallowLambdaCapture.kt @@ -4,6 +4,7 @@ import arrow.meta.Diagnostics import arrow.meta.FirMetaCheckerContext import arrow.meta.Meta import arrow.meta.samples.DisallowLambdaCaptureErrors.UnsafeCaptureDetected +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction import org.jetbrains.kotlin.fir.declarations.InlineStatus import org.jetbrains.kotlin.fir.declarations.findArgumentByName @@ -16,9 +17,6 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.ConstantValueKind -import kotlin.contracts.ExperimentalContracts -import kotlin.contracts.InvocationKind -import kotlin.contracts.contract object DisallowLambdaCaptureErrors : Diagnostics.Error { val UnsafeCaptureDetected by error1() @@ -34,12 +32,12 @@ annotation class DisallowLambdaCapture(val msg: String = "") { override fun FirMetaCheckerContext.check(expression: FirFunctionCall) { val nameArg = expression - .disallowLambdaCaptureAnnotation()?.findArgumentByName(Name.identifier(DisallowLambdaCapture::msg.name)) + .disallowLambdaCaptureAnnotation(session)?.findArgumentByName(Name.identifier(DisallowLambdaCapture::msg.name)) val userMsg = if (nameArg is FirConstExpression<*> && nameArg.kind == ConstantValueKind.String) nameArg.value as? String else null scopeDeclarations.filterIsInstance().forEach { scope -> - if (scope != null && scope.inlineStatus != InlineStatus.Inline) { + if (scope.inlineStatus != InlineStatus.Inline) { expression.report( UnsafeCaptureDetected, userMsg @@ -49,12 +47,13 @@ annotation class DisallowLambdaCapture(val msg: String = "") { } } - private fun FirFunctionCall.disallowLambdaCaptureAnnotation(): FirAnnotation? = + private fun FirFunctionCall.disallowLambdaCaptureAnnotation(session: FirSession): FirAnnotation? = toResolvedCallableSymbol()?.fir?.getAnnotationByClassId( ClassId( FqName(annotation.`package`.name), Name.identifier(annotation.simpleName) - ) + ), + session ) } } diff --git a/sandbox/src/main/kotlin/Sample.kt b/sandbox/src/main/kotlin/Sample.kt index e8e3b08..ef16dd7 100644 --- a/sandbox/src/main/kotlin/Sample.kt +++ b/sandbox/src/main/kotlin/Sample.kt @@ -9,7 +9,7 @@ interface Raise { } context(Raise) -fun shouldNotCature(): () -> Unit { +fun shouldNotCapture(): () -> Unit { return { raise("boom") } }