Bugfix/identity origin

core/src/main/kotlin/com/strumenta/kolasu/mapping/Support.kt

@@ -1,5 +1,6 @@
 package com.strumenta.kolasu.mapping
 
+import com.strumenta.kolasu.model.Node
 import com.strumenta.kolasu.parsing.getOriginalText
 import com.strumenta.kolasu.transformation.ASTTransformer
 import org.antlr.v4.runtime.ParserRuleContext
@@ -12,8 +13,8 @@ import org.antlr.v4.runtime.ParserRuleContext
  * JPostIncrementExpr(translateCasted<JExpression>(expression().first()))
  * ```
  */
-fun <T> ASTTransformer.translateCasted(original: Any): T {
-    val result = transform(original)
+inline fun <reified T : Node> ASTTransformer.translateCasted(original: Any): T {
+    val result = transform(original, expectedType = T::class)
     if (result is Nothing) {
         throw IllegalStateException("Transformation produced Nothing")
     }
@@ -29,8 +30,9 @@ fun <T> ASTTransformer.translateCasted(original: Any): T {
  * JExtendsType(translateCasted(pt.typeType()), translateList(pt.annotation()))
  * ```
  */
-fun <T> ASTTransformer.translateList(original: Collection<out Any>?): MutableList<T> {
-    return original?.map { transformIntoNodes(it) as List<T> }?.flatten()?.toMutableList() ?: mutableListOf()
+inline fun <reified T : Node> ASTTransformer.translateList(original: Collection<out Any>?): MutableList<T> {
+    return original?.map { transformIntoNodes(it, expectedType = T::class) as List<T> }?.flatten()?.toMutableList()
+        ?: mutableListOf()
 }
 
 /**
@@ -46,8 +48,15 @@ fun <T> ASTTransformer.translateList(original: Collection<out Any>?): MutableLis
  *  )
  *  ```
  */
-fun <T> ASTTransformer.translateOptional(original: Any?): T? {
-    return original?.let { transform(it) as T }
+inline fun <reified T : Node> ASTTransformer.translateOptional(original: Any?): T? {
+    return original?.let {
+        val transformed = transform(it, expectedType = T::class)
+        if (transformed == null) {
+            return null
+        } else {
+            transformed as T
+        }
+    }
 }
 
 /**

core/src/main/kotlin/com/strumenta/kolasu/transformation/IdentityTransformation.kt

@@ -0,0 +1,62 @@
+package com.strumenta.kolasu.transformation
+
+import com.strumenta.kolasu.mapping.translateList
+import com.strumenta.kolasu.model.Node
+import java.lang.reflect.ParameterizedType
+import kotlin.reflect.KClass
+import kotlin.reflect.KParameter
+import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.jvm.javaType
+
+val IDENTTITY_TRANSFORMATION: (
+    source: Any?,
+    parent: Node?,
+    expectedType: KClass<out Node>,
+    astTransformer: ASTTransformer
+) -> List<Node> = {
+        source: Any?, parent: Node?, expectedType: KClass<out Node>, astTransformer: ASTTransformer ->
+    when (source) {
+        null -> {
+            emptyList()
+        }
+        is Node -> {
+            val kClass = source.javaClass.kotlin
+            val primaryConstructor = kClass.primaryConstructor
+                ?: throw IllegalStateException(
+                    "No primary constructor found for $kClass: cannot apply " +
+                        "identity transformation"
+                )
+            val params = mutableMapOf<KParameter, Any?>()
+            primaryConstructor.parameters.forEach { parameter ->
+                val mt = parameter.type.javaType
+                val correspondingProperty = source.javaClass.kotlin.memberProperties.find {
+                    it.name == parameter.name
+                } ?: throw IllegalStateException(
+                    "Cannot find property named as parameter $parameter"
+                )
+                val originalValue = correspondingProperty.get(source)
+                // mt is ParameterizedType && mt.rawType == List::class.java -> mutableListOf<Any>()
+                when {
+                    (parameter.type.classifier as KClass<*>).isSubclassOf(Node::class) -> {
+                        params[parameter] = astTransformer.transform(originalValue)
+                    }
+                    mt is ParameterizedType && mt.rawType == List::class.java &&
+                        (mt.actualTypeArguments.first() as? Class<*>)?.kotlin?.isSubclassOf(Node::class) == true -> {
+                        params[parameter] = astTransformer.translateList<Node>(originalValue as List<Node>)
+                    }
+                    else -> params[parameter] = originalValue
+                }
+            }
+
+            val newInstance = primaryConstructor.callBy(params) as Node
+            newInstance.parent = parent
+            newInstance.origin = source
+            listOf(newInstance)
+        }
+        else -> {
+            throw IllegalArgumentException("An Identity Transformation expect to receive a Node")
+        }
+    }
+}

core/src/main/kotlin/com/strumenta/kolasu/transformation/Transformation.kt

@@ -258,7 +258,13 @@ open class ASTTransformer(
      * with the origin FailingASTTransformation. If the flag is not set, then the transformation will just
      * fail.
      */
-    val faultTollerant: Boolean = !throwOnUnmappedNode
+    val faultTollerant: Boolean = !throwOnUnmappedNode,
+    val defaultTransformation: (
+        (
+            source: Any?, parent: Node?, expectedType: KClass<out Node>,
+            astTransformer: ASTTransformer
+        ) -> List<Node>
+    )? = null
 ) {
     /**
      * Factories that map from source tree node to target tree node.
@@ -272,8 +278,8 @@ open class ASTTransformer(
      * This ensures that the generated value is a single Node or null.
      */
     @JvmOverloads
-    fun transform(source: Any?, parent: Node? = null): Node? {
-        val result = transformIntoNodes(source, parent)
+    fun transform(source: Any?, parent: Node? = null, expectedType: KClass<out Node> = Node::class): Node? {
+        val result = transformIntoNodes(source, parent, expectedType)
         return when (result.size) {
             0 -> null
             1 -> {
@@ -314,7 +320,9 @@ open class ASTTransformer(
                 node.parent = parent
             }
         } else {
-            if (allowGenericNode) {
+            if (defaultTransformation != null) {
+                nodes = defaultTransformation.invoke(source, parent, expectedType, this)
+            } else if (allowGenericNode) {
                 val origin = asOrigin(source)
                 nodes = listOf(GenericNode(parent).withOrigin(origin))
                 issues.add(

core/src/test/kotlin/com/strumenta/kolasu/transformation/ASTTransformerTest.kt

@@ -1,6 +1,9 @@
 package com.strumenta.kolasu.transformation
 
+import com.strumenta.kolasu.mapping.translateCasted
+import com.strumenta.kolasu.mapping.translateList
 import com.strumenta.kolasu.model.Node
+import com.strumenta.kolasu.model.children
 import com.strumenta.kolasu.model.hasValidParents
 import com.strumenta.kolasu.model.withOrigin
 import com.strumenta.kolasu.testing.assertASTsAreEqual
@@ -349,11 +352,195 @@ class ASTTransformerTest {
         )
         assertIs<MissingASTTransformation>(bazRoot1.stmts[0].origin)
     }
-}
 
+    @Test
+    fun testIdentityTransformation() {
+        val transformer = ASTTransformer(defaultTransformation = IDENTTITY_TRANSFORMATION)
+
+        val original = BarRoot(
+            stmts = mutableListOf(
+                BarStmt("a"),
+                BarStmt("b")
+            )
+        )
+        val transformed = transformer.transform(original) as Node
+        assertASTsAreEqual(
+            original,
+            transformed
+        )
+    }
+
+    @Test
+    fun testPartialIdentityTransformation() {
+        val transformer1 = ASTTransformer(defaultTransformation = IDENTTITY_TRANSFORMATION)
+        transformer1.registerNodeFactory(BarRoot::class) { original: BarRoot, astTransformer: ASTTransformer, _ ->
+            FooRoot(
+                desc = "#children = ${original.children.size}",
+                stmts = astTransformer.translateList(original.stmts)
+            )
+        }
+        val original = BarRoot(
+            stmts = mutableListOf(
+                BarStmt("a"),
+                BarStmt("b")
+            )
+        )
+        val transformed = transformer1.transform(original) as FooRoot
+        assertASTsAreEqual(
+            FooRoot(
+                "#children = 2",
+                mutableListOf(
+                    BarStmt("a"),
+                    BarStmt("b")
+                )
+            ),
+            transformed
+        )
+    }
+
+    @Test
+    fun testIdentityTransformationOfIntermediateNodes() {
+        val transformer1 = ASTTransformer(defaultTransformation = IDENTTITY_TRANSFORMATION)
+        transformer1.registerNodeFactory(BarRoot::class) { original: BarRoot, astTransformer: ASTTransformer, _ ->
+            FooRoot(
+                desc = "#children = ${original.children.size}",
+                stmts = astTransformer.translateList(original.stmts)
+            )
+        }
+        val original = AA(
+            a = "my_a",
+            child = AB(
+                b = "my_b",
+                child = AC(
+                    c = "my_c",
+                    children = mutableListOf(
+                        AD("my_d1"),
+                        AD("my_d2"),
+                        AD("my_d3")
+                    )
+                )
+            )
+        )
+        // All identity
+        assertASTsAreEqual(
+            AA(
+                a = "my_a",
+                child = AB(
+                    b = "my_b",
+                    child = AC(
+                        c = "my_c",
+                        children = mutableListOf(
+                            AD("my_d1"),
+                            AD("my_d2"),
+                            AD("my_d3")
+                        )
+                    )
+                )
+            ),
+            transformer1.transform(original) as AA
+        )
+        // All identity besides AA
+        transformer1.registerNodeFactory(AA::class) { original, t, _ ->
+            BA("your_" + original.a.removePrefix("my_"), t.translateCasted(original.child))
+        }
+        assertASTsAreEqual(
+            BA(
+                a = "your_a",
+                child = AB(
+                    b = "my_b",
+                    child = AC(
+                        c = "my_c",
+                        children = mutableListOf(
+                            AD("my_d1"),
+                            AD("my_d2"),
+                            AD("my_d3")
+                        )
+                    )
+                )
+            ),
+            transformer1.transform(original) as AA
+        )
+        // All identity besides AA and AB
+        transformer1.registerNodeFactory(AB::class) { original, t, _ ->
+            BB("your_" + original.b.removePrefix("my_"), t.translateCasted(original.child))
+        }
+        assertASTsAreEqual(
+            BA(
+                a = "your_a",
+                child = BB(
+                    b = "your_b",
+                    child = AC(
+                        c = "my_c",
+                        children = mutableListOf(
+                            AD("my_d1"),
+                            AD("my_d2"),
+                            AD("my_d3")
+                        )
+                    )
+                )
+            ),
+            transformer1.transform(original) as AA
+        )
+        // All identity besides AA and AB and AD
+        transformer1.registerNodeFactory(AD::class) { original, t, _ ->
+            BD("your_" + original.d.removePrefix("my_"))
+        }
+        assertASTsAreEqual(
+            BA(
+                a = "your_a",
+                child = BB(
+                    b = "your_b",
+                    child = AC(
+                        c = "my_c",
+                        children = mutableListOf(
+                            BD("your_d1"),
+                            BD("your_d2"),
+                            BD("your_d3")
+                        )
+                    )
+                )
+            ),
+            transformer1.transform(original) as AA
+        )
+    }
+
+    @Test
+    fun testIdentityTransformationOfIntermediateNodesWithOrigin() {
+        val transformer1 = ASTTransformer(defaultTransformation = IDENTTITY_TRANSFORMATION)
+        transformer1.registerNodeFactory(AA::class) { original, t, _ ->
+            BA("your_" + original.a.removePrefix("my_"), t.translateCasted(original.child))
+        }
+        val original = AA(
+            a = "my_a",
+            child = AB(
+                b = "my_b",
+                child = AC(
+                    c = "my_c",
+                    children = mutableListOf(
+                        AD("my_d1")
+                    )
+                )
+            )
+        )
+        val transformedAST = transformer1.transform(original) as AA
+        // verify that the origin is set correctly
+        assert(transformedAST.origin == original)
+    }
+}
 data class BazRoot(var stmts: MutableList<BazStmt> = mutableListOf()) : Node()
 
 data class BazStmt(val desc: String? = null) : Node()
 
 data class BarRoot(var stmts: MutableList<BarStmt> = mutableListOf()) : Node()
 data class BarStmt(val desc: String) : Node()
+
+data class FooRoot(var desc: String, var stmts: MutableList<BarStmt> = mutableListOf()) : Node()
+
+open class AA(var a: String, val child: AB) : Node()
+open class AB(var b: String, val child: AC) : Node()
+open class AC(var c: String, val children: MutableList<AD>) : Node()
+open class AD(var d: String) : Node()
+
+class BA(a: String, child: AB) : AA(a, child)
+class BB(b: String, child: AC) : AB(b, child)
+class BD(d: String) : AD(d)

gradle.properties

@@ -1,4 +1,4 @@
-version=1.5.75-SNAPSHOT
+version=1.5.77-SNAPSHOT
 # Note that we use the EXACT same version of Kotlin as the one included in Gradle, to avoid
 # conflicts
 kotlin_version=1.8.20

gradle/libs.versions.toml

@@ -4,8 +4,8 @@ superPublish = { id = "com.vanniktech.maven.publish", version = "0.22.0" }
 ktlint = { id = "org.jlleitschuh.gradle.ktlint", version = "11.5.1" }
 
 [versions]
-lwjava = "0.3.0"
-lwkotlin = "0.3.0"
+lwjava = "0.3.1"
+lwkotlin = "0.3.2"
 kotestVersion= "1.3.3"
 
 [libraries]

lionweb-gen-gradle/src/main/kotlin/com/strumenta/kolasu/lionwebgen/LionWebGradlePlugin.kt

@@ -3,6 +3,7 @@ package com.strumenta.kolasu.lionwebgen
 import com.google.devtools.ksp.gradle.KspExtension
 import com.strumenta.kolasu.lionweb.ASTGenerator
 import com.strumenta.kolasu.lionweb.KotlinCodeProcessor
+import com.strumenta.kolasu.lionweb.LIONWEB_VERSION_USED_BY_KOLASU
 import com.strumenta.kolasu.lionweb.StarLasuLWLanguage
 import io.lionweb.lioncore.java.language.Language
 import io.lionweb.lioncore.java.serialization.JsonSerialization
@@ -46,7 +47,8 @@ class LionWebGradlePlugin : Plugin<Project> {
                     println("processing languageFile $languageFile")
                     when (languageFile.extension) {
                         "json" -> {
-                            val jsonser = SerializationProvider.getStandardJsonSerialization()
+                            val jsonser = SerializationProvider.getStandardJsonSerialization(
+                                LIONWEB_VERSION_USED_BY_KOLASU)
                             jsonser.instanceResolver.addTree(StarLasuLWLanguage)
                             val language = jsonser.deserializeToNodes(FileInputStream(languageFile)).first() as Language
                             val existingKotlinClasses = KotlinCodeProcessor().classesDeclaredInDir(project.file("src/main/kotlin"))
@@ -164,7 +166,7 @@ class LionWebGradlePlugin : Plugin<Project> {
         addKolasuModule("lionweb-gen")
         project.dependencies.add("ksp", "com.strumenta.kolasu:kolasu-lionweb-ksp:${project.kolasuVersion}")
         project.dependencies.add("api", "com.github.ajalt.clikt:clikt:3.5.0")
-        project.dependencies.add("api", "io.lionweb.lionweb-java:lionweb-java-2023.1-core:${project.lionwebJavaVersion}")
+        project.dependencies.add("api", "io.lionweb.lionweb-java:lionweb-java-2024.1-core:${project.lionwebJavaVersion}")
     }
 
 }