Generate internal, open IR classes and tree rewriters (#1109)

CHANGELOG.md

@@ -102,6 +102,8 @@ Thank you to all who have contributed!
 - **Breaking**: Removes deprecated `org.partiql.lang.syntax.SourceSpan`
 - **Breaking**: Removes deprecated `org.partiql.lang.syntax.Token`
 - **Breaking**: Removes deprecated `org.partiql.lang.syntax.TokenType`
+- **Breaking**: Plan nodes cannot be directly instantiated. To instantiate, use the `Plan` (DEFAULT) factory.
+- **Breaking**: PlanRewriter has been moved from `org.partiql.plan.visitor.PlanRewriter` to `org.partiql.plan.util.PlanRewriter`
 
 ### Security
 

buildSrc/src/main/kotlin/partiql.versions.kt

@@ -37,7 +37,7 @@ object Versions {
     const val jline = "3.21.0"
     const val jmh = "0.5.3"
     const val joda = "2.12.1"
-    const val kotlinPoet = "1.8.0"
+    const val kotlinPoet = "1.11.0"
     const val picoCli = "4.7.0"
     const val kasechange = "1.3.0"
     const val ktlint = "10.2.1"

lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinCommand.kt

@@ -46,23 +46,13 @@ class KotlinCommand : Callable<Int> {
     )
     var poems: List<String> = emptyList()
 
-    @CommandLine.Option(
-        names = ["-m", "--modifier"],
-        description = ["Generated node class modifier. Options \${COMPLETION-CANDIDATES}"],
-        defaultValue = "DATA"
-    )
-    lateinit var modifier: KotlinNodeOptions.Modifier
-
     override fun call(): Int {
         val input = BufferedReader(FileInputStream(file).reader()).readText()
         val parser = SproutParser.default()
         val universe = parser.parse(id, input)
         val options = KotlinOptions(
             packageRoot = packageRoot,
             poems = poems,
-            node = KotlinNodeOptions(
-                modifier = modifier,
-            ),
         )
         val generator = KotlinGenerator(options)
         val result = generator.generate(universe)

lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinGenerator.kt

@@ -1,5 +1,7 @@
 package org.partiql.sprout.generator.target.kotlin
 
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.FunSpec
 import com.squareup.kotlinpoet.KModifier
 import com.squareup.kotlinpoet.ParameterSpec
 import com.squareup.kotlinpoet.PropertySpec
@@ -9,7 +11,7 @@ import org.partiql.sprout.generator.Generator
 import org.partiql.sprout.generator.target.kotlin.poems.KotlinBuilderPoem
 import org.partiql.sprout.generator.target.kotlin.poems.KotlinJacksonPoem
 import org.partiql.sprout.generator.target.kotlin.poems.KotlinListenerPoem
-import org.partiql.sprout.generator.target.kotlin.poems.KotlinMetasPoem
+import org.partiql.sprout.generator.target.kotlin.poems.KotlinUtilsPoem
 import org.partiql.sprout.generator.target.kotlin.poems.KotlinVisitorPoem
 import org.partiql.sprout.generator.target.kotlin.spec.KotlinFileSpec
 import org.partiql.sprout.generator.target.kotlin.spec.KotlinNodeSpec
@@ -35,20 +37,22 @@ class KotlinGenerator(private val options: KotlinOptions) : Generator<KotlinResu
                 "visitor" -> KotlinVisitorPoem(symbols)
                 "builder" -> KotlinBuilderPoem(symbols)
                 "listener" -> KotlinListenerPoem(symbols)
-                "metas" -> KotlinMetasPoem(symbols)
                 "jackson" -> KotlinJacksonPoem(symbols)
-                else -> error("unknown poem $it, expected: visitor, builder, listener, metas, jackson")
+                "util" -> KotlinUtilsPoem(symbols)
+                else -> error("unknown poem $it, expected: visitor, builder, listener, jackson, util")
             }
         }
 
         // --- Generate skeleton
         val spec = KotlinUniverseSpec(
             universe = universe,
             nodes = universe.nodes(symbols),
-            base = TypeSpec.classBuilder(symbols.base).addModifiers(KModifier.ABSTRACT),
+            base = TypeSpec.interfaceBuilder(symbols.base),
             types = universe.types(symbols)
         )
         val specs = with(spec) {
+            // Add identifiers
+            base.addProperty(PropertySpec.builder("_id", String::class).addModifiers(KModifier.ABSTRACT).build())
             // Apply each poem
             poems.forEach { it.apply(this) }
             // Finalize each spec/builder
@@ -62,18 +66,17 @@ class KotlinGenerator(private val options: KotlinOptions) : Generator<KotlinResu
     /**
      * Generate a NodeSpec for each Type in the given Universe
      */
-    private fun Universe.nodes(symbols: KotlinSymbols): List<KotlinNodeSpec> = types.mapNotNull { it.generate(symbols) }
-        .map {
-            it.builder.superclass(symbols.base)
+    private fun Universe.nodes(symbols: KotlinSymbols): List<KotlinNodeSpec> =
+        types.mapNotNull { it.generate(symbols) }.map {
+            it.builder.addSuperinterface(symbols.base)
             it
         }
 
     /**
      * Generate all top-level enums as these are not children of a product definition
      */
-    private fun Universe.types(symbols: KotlinSymbols) = types.filterIsInstance<TypeDef.Enum>()
-        .map { it.generate(symbols) }
-        .toMutableList()
+    private fun Universe.types(symbols: KotlinSymbols) =
+        types.filterIsInstance<TypeDef.Enum>().map { it.generate(symbols) }.toMutableList()
 
     /**
      * Entry point for node generation.
@@ -87,25 +90,36 @@ class KotlinGenerator(private val options: KotlinOptions) : Generator<KotlinResu
     /**
      * Product Node Generation
      */
-    private fun TypeDef.Product.generate(symbols: KotlinSymbols) = KotlinNodeSpec.Product(
-        product = this,
-        props = props.map { KotlinNodeSpec.Prop(it.name.toCamelCase(), symbols.typeNameOf(it.ref)) },
-        nodes = children.mapNotNull { it.generate(symbols) },
-        clazz = symbols.clazz(ref),
-        ext = (props.enumProps(symbols) + types.enums(symbols)).toMutableList(),
-    ).apply {
-        props.forEach {
-            val para = ParameterSpec.builder(it.name, it.type).build()
-            val prop = PropertySpec.builder(it.name, it.type).initializer(it.name).build()
-            builder.addProperty(prop)
-            constructor.addParameter(para)
-        }
-        when (options.node.modifier) {
-            KotlinNodeOptions.Modifier.FINAL -> {}
-            KotlinNodeOptions.Modifier.DATA -> if (props.isNotEmpty()) builder.addModifiers(KModifier.DATA)
-            KotlinNodeOptions.Modifier.OPEN -> builder.addModifiers(KModifier.OPEN)
+    private fun TypeDef.Product.generate(symbols: KotlinSymbols): KotlinNodeSpec {
+        val clazz = symbols.clazz(ref)
+        val clazzImpl = ClassName(
+            packageName = clazz.packageName + ".impl",
+            simpleNames = listOf(symbols.pascal(ref) + "Impl"),
+        )
+        return KotlinNodeSpec.Product(
+            product = this,
+            props = props.map { KotlinNodeSpec.Prop(it.name.toCamelCase(), symbols.typeNameOf(it.ref)) },
+            implClazz = clazzImpl,
+            impl = TypeSpec.classBuilder(clazzImpl),
+            nodes = children.mapNotNull { it.generate(symbols) },
+            clazz = symbols.clazz(ref),
+            ext = (props.enumProps(symbols) + types.enums(symbols)).toMutableList(),
+        ).apply {
+            // Add id to impl
+            impl.addProperty(symbols.idProp)
+            constructor.addParameter(symbols.idPara)
+            props.forEach {
+                val para = ParameterSpec.builder(it.name, it.type).build()
+                val prop = PropertySpec.builder(it.name, it.type).build()
+                builder.addProperty(prop.toBuilder().addModifiers(KModifier.ABSTRACT).build())
+                impl.addProperty(prop.toBuilder().addModifiers(KModifier.OVERRIDE).initializer(it.name).build())
+                constructor.addParameter(para)
+            }
+            // impls are open
+            impl.addSuperinterface(clazz)
+            nodes.forEach { it.builder.addSuperinterface(symbols.base) }
+            this.addDataClassMethods()
         }
-        nodes.forEach { it.builder.superclass(symbols.base) }
     }
 
     /**
@@ -118,16 +132,15 @@ class KotlinGenerator(private val options: KotlinOptions) : Generator<KotlinResu
         clazz = symbols.clazz(ref),
         ext = types.enums(symbols).toMutableList(),
     ).apply {
-        variants.forEach { it.builder.superclass(clazz) }
-        nodes.forEach { it.builder.superclass(symbols.base) }
+        variants.forEach { it.builder.addSuperinterface(clazz) }
+        nodes.forEach { it.builder.addSuperinterface(symbols.base) }
     }
 
     /**
      * Enum constant generation
      */
-    private fun TypeDef.Enum.generate(symbols: KotlinSymbols) = TypeSpec.enumBuilder(symbols.clazz(ref))
-        .apply { values.forEach { addEnumConstant(it) } }
-        .build()
+    private fun TypeDef.Enum.generate(symbols: KotlinSymbols) =
+        TypeSpec.enumBuilder(symbols.clazz(ref)).apply { values.forEach { addEnumConstant(it) } }.build()
 
     private fun List<TypeProp>.enumProps(symbols: KotlinSymbols) = filterIsInstance<TypeProp.Inline>().mapNotNull {
         when (it.def) {
@@ -139,4 +152,30 @@ class KotlinGenerator(private val options: KotlinOptions) : Generator<KotlinResu
     private fun List<TypeDef>.enums(symbols: KotlinSymbols) = filterIsInstance<TypeDef.Enum>().map {
         it.generate(symbols)
     }
+
+    // TODO generate hashCode, equals, componentN so we can have OPEN internal implementations
+    private fun KotlinNodeSpec.Product.addDataClassMethods() {
+        impl.addModifiers(KModifier.INTERNAL, KModifier.OPEN)
+        // builder.addFunction(
+        //     FunSpec.builder("hashCode").addModifiers(KModifier.OVERRIDE, KModifier.ABSTRACT).returns(Int::class).build()
+        // )
+        // builder.addFunction(
+        //     FunSpec.builder("equals").addModifiers(KModifier.OVERRIDE, KModifier.ABSTRACT).returns(Boolean::class)
+        //         .addParameter(ParameterSpec.builder("other", Any::class.asTypeName().copy(nullable = true)).build())
+        //         .build()
+        // )
+        val args = listOf("_id") + props.map { it.name }
+        val copy = FunSpec.builder("copy").addModifiers(KModifier.ABSTRACT).returns(clazz)
+        val copyImpl = FunSpec.builder("copy")
+            .addModifiers(KModifier.OVERRIDE)
+            .returns(clazz)
+            .addStatement("return %T(${args.joinToString()})", implClazz)
+        props.forEach {
+            val para = ParameterSpec.builder(it.name, it.type).build()
+            copy.addParameter(para.toBuilder().defaultValue("this.${it.name}").build())
+            copyImpl.addParameter(para)
+        }
+        builder.addFunction(copy.build())
+        impl.addFunction(copyImpl.build())
+    }
 }

lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinOptions.kt

@@ -8,19 +8,4 @@ package org.partiql.sprout.generator.target.kotlin
 class KotlinOptions(
     val packageRoot: String,
     val poems: List<String>,
-    val node: KotlinNodeOptions = KotlinNodeOptions(),
 )
-
-/**
- * Consider other options as this is Kotlin specific
- */
-class KotlinNodeOptions(
-    val modifier: Modifier = Modifier.FINAL,
-) {
-
-    enum class Modifier {
-        FINAL,
-        DATA,
-        OPEN,
-    }
-}

lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinSymbols.kt

@@ -6,13 +6,16 @@ import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.DOUBLE
 import com.squareup.kotlinpoet.FLOAT
 import com.squareup.kotlinpoet.INT
+import com.squareup.kotlinpoet.KModifier
 import com.squareup.kotlinpoet.LIST
 import com.squareup.kotlinpoet.LONG
 import com.squareup.kotlinpoet.MAP
 import com.squareup.kotlinpoet.MUTABLE_LIST
 import com.squareup.kotlinpoet.MUTABLE_MAP
 import com.squareup.kotlinpoet.MUTABLE_SET
+import com.squareup.kotlinpoet.ParameterSpec
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.PropertySpec
 import com.squareup.kotlinpoet.SET
 import com.squareup.kotlinpoet.STRING
 import com.squareup.kotlinpoet.TypeName
@@ -51,6 +54,16 @@ class KotlinSymbols private constructor(
      */
     val base: ClassName = ClassName(rootPackage, "${rootId}Node")
 
+    /**
+     * Id Property for interfaces and classes
+     */
+    val idProp = PropertySpec.builder("_id", String::class).addModifiers(KModifier.OVERRIDE).initializer("_id").build()
+
+    /**
+     * Id Parameter for internal constructors
+     */
+    val idPara = ParameterSpec.builder("_id", String::class).build()
+
     /**
      * Memoize converting a TypeRef.Path to a camel case identifier to be used as method/function names
      */