From 851c68410e44c59cfbf1bf3c27658bd6c04d637b Mon Sep 17 00:00:00 2001
From: Xavier Gouchet <xavier.gouchet@gmail.com>
Date: Tue, 3 Oct 2023 18:58:23 +0200
Subject: [PATCH] Create KSP implementation

---
 .idea/gradle.xml                              |   1 +
 gradle/libs.versions.toml                     |   2 +
 ksp/build.gradle.kts                          |  34 ++
 .../xgouchet/elmyr/ksp/ForgerableProcessor.kt | 293 +++++++++++
 .../elmyr/ksp/ForgerableProcessorProvider.kt  |  17 +
 ...ols.ksp.processing.SymbolProcessorProvider |   1 +
 .../ksp/ForgerableProcessorProviderTest.kt    | 457 ++++++++++++++++++
 settings.gradle.kts                           |   1 +
 8 files changed, 806 insertions(+)
 create mode 100644 ksp/build.gradle.kts
 create mode 100644 ksp/src/main/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessor.kt
 create mode 100644 ksp/src/main/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessorProvider.kt
 create mode 100644 ksp/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider
 create mode 100644 ksp/src/test/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessorProviderTest.kt

diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 0df879f..98f6939 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -28,6 +28,7 @@
             <option value="$PROJECT_DIR$/junit4" />
             <option value="$PROJECT_DIR$/junit5" />
             <option value="$PROJECT_DIR$/jvm" />
+            <option value="$PROJECT_DIR$/ksp" />
             <option value="$PROJECT_DIR$/semantics" />
             <option value="$PROJECT_DIR$/spek" />
           </set>
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 8281b4f..6161a62 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,5 +1,6 @@
 [versions]
 kotlin = "1.8.10"
+kotlinSP = "1.8.10-1.0.9"
 
 junitJupiter = "5.9.3"
 junitPlatform = "1.9.3"
@@ -21,6 +22,7 @@ nexusPublish = "1.1.0"
 kotlin = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
 kotlinReflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
 kotlinGP = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+kotlinSP = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "kotlinSP" }
 
 junitPlatform = { module = "org.junit.platform:junit-platform-launcher", version.ref = "junitPlatform" }
 junitVintage = { module = "org.junit.vintage:junit-vintage-engine", version.ref = "junitVintage" }
diff --git a/ksp/build.gradle.kts b/ksp/build.gradle.kts
new file mode 100644
index 0000000..219722b
--- /dev/null
+++ b/ksp/build.gradle.kts
@@ -0,0 +1,34 @@
+import fr.xgouchet.buildsrc.settings.commonConfig
+
+plugins {
+    kotlin("jvm")
+    id("com.github.ben-manes.versions")
+    id("io.gitlab.arturbosch.detekt")
+    id("org.jlleitschuh.gradle.ktlint")
+    id("org.jetbrains.dokka")
+    `maven-publish`
+    signing
+}
+
+dependencies {
+
+    implementation(project(":core"))
+    implementation(libs.kotlin)
+    implementation(libs.kotlinSP)
+
+    implementation("com.squareup:kotlinpoet:1.14.2") {
+        exclude(module = "kotlin-reflect")
+    }
+    implementation("com.squareup:kotlinpoet-ksp:1.14.2")
+
+    testImplementation(project(":inject"))
+    testImplementation(project(":junit5"))
+
+    testImplementation(libs.bundles.junit5)
+    testImplementation(libs.assertJ)
+    testImplementation(libs.mockitoJunit5)
+    testImplementation(libs.mockitoKotlin)
+    testImplementation("com.github.tschuchortdev:kotlin-compile-testing-ksp:1.5.0")
+}
+
+commonConfig("KSP project")
diff --git a/ksp/src/main/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessor.kt b/ksp/src/main/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessor.kt
new file mode 100644
index 0000000..019bf63
--- /dev/null
+++ b/ksp/src/main/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessor.kt
@@ -0,0 +1,293 @@
+package fr.xgouchet.elmyr.ksp
+
+import com.google.devtools.ksp.processing.CodeGenerator
+import com.google.devtools.ksp.processing.Dependencies
+import com.google.devtools.ksp.processing.KSPLogger
+import com.google.devtools.ksp.processing.Resolver
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.symbol.KSAnnotated
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+import com.google.devtools.ksp.symbol.KSFile
+import com.google.devtools.ksp.symbol.KSFunctionDeclaration
+import com.google.devtools.ksp.symbol.KSName
+import com.google.devtools.ksp.symbol.KSNode
+import com.google.devtools.ksp.symbol.KSValueParameter
+import com.google.devtools.ksp.symbol.Modifier
+import com.google.devtools.ksp.visitor.KSDefaultVisitor
+import com.squareup.kotlinpoet.BOOLEAN
+import com.squareup.kotlinpoet.BYTE
+import com.squareup.kotlinpoet.CHAR
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.CodeBlock
+import com.squareup.kotlinpoet.DOUBLE
+import com.squareup.kotlinpoet.FLOAT
+import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.INT
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.LONG
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.SHORT
+import com.squareup.kotlinpoet.STRING
+import com.squareup.kotlinpoet.TypeName
+import com.squareup.kotlinpoet.TypeSpec
+import com.squareup.kotlinpoet.ksp.toKModifier
+import com.squareup.kotlinpoet.ksp.toTypeName
+import java.io.IOException
+import java.io.OutputStreamWriter
+
+/**
+ * A Kotlin [SymbolProcessor] generating a [ForgeryFactory] implementation for every
+ * data class in the compiled project.
+ * @property codeGenerator the [CodeGenerator] used to create new code
+ * @property logger the [KSPLogger] reporting info, warnings and errors while processing symbols
+ */
+class ForgerableProcessor(
+    val codeGenerator: CodeGenerator,
+    val logger: KSPLogger
+) : SymbolProcessor {
+
+    private var invoked = false
+
+    /** @inheritdoc */
+    override fun process(resolver: Resolver): List<KSAnnotated> {
+        if (invoked) {
+            logger.info("Already invoked, ignoring")
+            return emptyList()
+        }
+
+        logger.info("Processing…")
+
+        val visitor = FileVisitor(ClassVisitor(ConstructorVisitor()))
+        val dataClasses = resolver.getAllFiles()
+
+        dataClasses.map {
+            it.accept(visitor, Unit)
+        }.toList()
+
+        invoked = true
+
+        return emptyList()
+    }
+
+    private inner class FileVisitor(
+        val classVisitor: KSDefaultVisitor<KSFile, Unit>
+    ) : KSDefaultVisitor<Unit, Unit>() {
+
+        override fun visitFile(file: KSFile, data: Unit) {
+            logger.info("… File ${file.fileName}")
+
+            file.declarations.forEach {
+                it.accept(classVisitor, file)
+            }
+
+            logger.info("✔ File ${file.fileName}")
+        }
+
+        override fun defaultHandler(node: KSNode, data: Unit) {
+            // no-op
+        }
+    }
+
+    private inner class ClassVisitor(
+        val constructorVisitor: KSDefaultVisitor<ConstructorContext, Unit>
+    ) : KSDefaultVisitor<KSFile, Unit>() {
+
+        override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: KSFile) {
+            val classKind = classDeclaration.classKind
+            val className = classDeclaration.simpleName.asString()
+            logger.info("… $classKind $className")
+
+            val modifiers = classDeclaration.modifiers
+            val visibility = modifiers.firstOrNull { it in VISIBILITY_MODIFIERS }
+            if (modifiers.contains(Modifier.DATA) && visibility in VISIBLE_MODIFIERS) {
+                val primaryConstructor = classDeclaration.primaryConstructor
+                val qualifiedName = classDeclaration.qualifiedName
+                if (primaryConstructor == null) {
+                    logger.warn("$classKind $className has no primary constructor")
+                } else if (qualifiedName == null) {
+                    logger.warn("$classKind $className has no primary constructor")
+                } else {
+                    val context = ConstructorContext(
+                        data,
+                        classDeclaration.packageName,
+                        qualifiedName,
+                        visibility
+                    )
+                    primaryConstructor.accept(constructorVisitor, context)
+                }
+            }
+
+            classDeclaration.declarations.forEach { it.accept(this, data) }
+
+            logger.info("✔ $classKind $className")
+        }
+
+        override fun defaultHandler(node: KSNode, data: KSFile) {
+            // no-op
+        }
+    }
+
+    private inner class ConstructorVisitor : KSDefaultVisitor<ConstructorContext, Unit>() {
+        override fun visitFunctionDeclaration(
+            function: KSFunctionDeclaration,
+            data: ConstructorContext
+        ) {
+            logger.info("… ${data.classQualifiedName.asString()}.${function.simpleName.asString()}()")
+
+            val fileSpec = generateFile(
+                function,
+                data.packageName,
+                data.visibility?.toKModifier(),
+                data.classQualifiedName
+            )
+            val dependencies = Dependencies(false, data.file)
+            try {
+                val outputStream = codeGenerator.createNewFile(
+                    dependencies,
+                    fileSpec.packageName,
+                    fileSpec.name
+                )
+                val writer = OutputStreamWriter(outputStream, Charsets.UTF_8)
+                fileSpec.writeTo(writer)
+                try {
+                    writer.flush()
+                    writer.close()
+                } catch (e: IOException) {
+                    logger.warn(
+                        "Error flushing writer for file ${fileSpec.packageName}.${fileSpec.name}: " +
+                            "${e.message}."
+                    )
+                }
+            } catch (e: IOException) {
+                logger.error("Error writing file ${fileSpec.packageName}.${fileSpec.name}")
+                logger.exception(e)
+            }
+
+            logger.info("✔ ${data.classQualifiedName.asString()}.${function.simpleName.asString()}()")
+        }
+
+        override fun defaultHandler(node: KSNode, data: ConstructorContext) {
+            // no-op
+        }
+
+        private fun generateFile(
+            function: KSFunctionDeclaration,
+            packageName: KSName,
+            visibility: KModifier?,
+            classQualifiedName: KSName
+        ): FileSpec {
+            val factoryName = "${classQualifiedName.getShortName()}ForgeryFactory"
+            logger.info("Creating file $factoryName")
+            val fileSpecBuilder = FileSpec.builder(packageName.asString(), factoryName)
+
+            fileSpecBuilder.addType(
+                generateForgeryType(
+                    function,
+                    classQualifiedName,
+                    visibility,
+                    factoryName
+                )
+            )
+
+            return fileSpecBuilder.indent("    ").build()
+        }
+
+        private fun generateForgeryType(
+            function: KSFunctionDeclaration,
+            classQualifiedName: KSName,
+            visibility: KModifier?,
+            factoryName: String
+        ): TypeSpec {
+            val returnType = ClassName.bestGuess(classQualifiedName.asString())
+            val builder = TypeSpec.classBuilder(factoryName)
+            if (visibility != null) {
+                builder.addModifiers(visibility)
+            }
+            return builder
+                .addSuperinterface(
+                    ClassName.bestGuess("fr.xgouchet.elmyr.ForgeryFactory")
+                        .parameterizedBy(returnType)
+                )
+                .addFunction(generateForgeryFun(function, returnType)).build()
+        }
+
+        private fun generateForgeryFun(
+            function: KSFunctionDeclaration,
+            returnType: TypeName
+        ): FunSpec {
+            val funSpecBuilder = FunSpec.builder("getForgery")
+                .addModifiers(KModifier.OVERRIDE).returns(returnType)
+                .addParameter("forge", ClassName.bestGuess("fr.xgouchet.elmyr.Forge"))
+
+            val statementBuilder = CodeBlock.builder()
+
+            function.parameters.forEach {
+                funSpecBuilder.addCode(generateParameterForgery(it))
+            }
+
+            val arguments = function.parameters.joinToString(", ") { "$it = $it" }
+
+            statementBuilder.addStatement("return %T(%L)", returnType, arguments)
+
+            return funSpecBuilder.addCode(statementBuilder.build()).build()
+        }
+
+        private fun generateParameterForgery(
+            parameter: KSValueParameter
+        ): CodeBlock {
+            logger.info("Converting type ${parameter.type}")
+            val resolvedType = parameter.type.resolve()
+            val isNullable = resolvedType.isMarkedNullable
+            val nonNullType = resolvedType.makeNotNullable()
+            val typeName = nonNullType.toTypeName()
+            val forgeryMethod = when {
+                typeName == STRING -> "aString()"
+                typeName == BOOLEAN -> "aBool()"
+                typeName == BYTE -> "aByte()"
+                typeName == SHORT -> "aShort()"
+                typeName == INT -> "anInt()"
+                typeName == LONG -> "aLong()"
+                typeName == FLOAT -> "aFloat()"
+                typeName == DOUBLE -> "aDouble()"
+                typeName == CHAR -> "aChar()"
+                else -> "getForgery()"
+            }
+            val forgeryStatement = if (isNullable) {
+                "forge.aNullable { $forgeryMethod }"
+            } else {
+                "forge.$forgeryMethod"
+            }
+
+            return CodeBlock.builder()
+                .addStatement(
+                    "val %L: %T = %L",
+                    parameter.name?.asString(),
+                    parameter.type.toTypeName(),
+                    forgeryStatement
+                ).build()
+        }
+    }
+
+    internal data class ConstructorContext(
+        val file: KSFile,
+        val packageName: KSName,
+        val classQualifiedName: KSName,
+        val visibility: Modifier?
+    )
+
+    companion object {
+        private val VISIBILITY_MODIFIERS = arrayOf(
+            Modifier.PUBLIC,
+            Modifier.PRIVATE,
+            Modifier.INTERNAL,
+            Modifier.PROTECTED
+        )
+
+        private val VISIBLE_MODIFIERS = arrayOf(
+            Modifier.PUBLIC,
+            Modifier.INTERNAL,
+            null
+        )
+    }
+}
diff --git a/ksp/src/main/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessorProvider.kt b/ksp/src/main/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessorProvider.kt
new file mode 100644
index 0000000..825f396
--- /dev/null
+++ b/ksp/src/main/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessorProvider.kt
@@ -0,0 +1,17 @@
+package fr.xgouchet.elmyr.ksp
+
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
+import com.google.devtools.ksp.processing.SymbolProcessorProvider
+
+/**
+ * a [SymbolProcessorProvider] providing a [ForgerableProcessor].
+ */
+class ForgerableProcessorProvider : SymbolProcessorProvider {
+    override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor {
+        return ForgerableProcessor(
+            environment.codeGenerator,
+            environment.logger
+        )
+    }
+}
diff --git a/ksp/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider b/ksp/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider
new file mode 100644
index 0000000..af9cf32
--- /dev/null
+++ b/ksp/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider
@@ -0,0 +1 @@
+fr.xgouchet.elmyr.ksp.ForgerableProcessorProvider
\ No newline at end of file
diff --git a/ksp/src/test/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessorProviderTest.kt b/ksp/src/test/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessorProviderTest.kt
new file mode 100644
index 0000000..56eb2f6
--- /dev/null
+++ b/ksp/src/test/kotlin/fr/xgouchet/elmyr/ksp/ForgerableProcessorProviderTest.kt
@@ -0,0 +1,457 @@
+package fr.xgouchet.elmyr.ksp
+
+import com.tschuchort.compiletesting.KotlinCompilation
+import com.tschuchort.compiletesting.SourceFile
+import com.tschuchort.compiletesting.symbolProcessorProviders
+import java.io.File
+import org.assertj.core.api.Assertions.assertThat
+import org.jetbrains.kotlin.config.JvmTarget
+import org.junit.jupiter.api.Test
+
+internal class ForgerableProcessorProviderTest {
+
+    @Test
+    fun ignoresClass() {
+        val className = "Bar"
+        val sourceContent = """
+    package com.example
+    class $className(
+        val message: String,
+        val timestamp: Long
+    )
+    """
+
+        testCompilation(
+            "$className.kt",
+            sourceContent
+        ) {
+            assertThat(it.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK)
+            it.assertNothingGenerated(className)
+        }
+    }
+
+    @Test
+    fun ignoresPrivateDataClass() {
+        val className = "Foo"
+        val parentClassName = "Bar"
+        val sourceContent = """
+    package com.example
+    
+    class $parentClassName {
+        private data class $className(
+            val message: String,
+            val timestamp: Long
+        )
+    }
+    """
+
+        testCompilation(
+            "$className.kt",
+            sourceContent
+        ) {
+            assertThat(it.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK)
+            it.assertNothingGenerated(className)
+        }
+    }
+
+    @Test
+    fun ignoresProtectedDataClass() {
+        val className = "Foo"
+        val parentClassName = "Bar"
+        val sourceContent = """
+    package com.example
+    
+    open class $parentClassName {
+        protected data class $className(
+            val message: String,
+            val timestamp: Long
+        )
+    }
+    """
+
+        testCompilation(
+            "$className.kt",
+            sourceContent
+        ) {
+            assertThat(it.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK)
+            it.assertNothingGenerated(className)
+        }
+    }
+
+    @Test
+    fun processDataClass() {
+        val className = "Foo"
+        val sourceContent = """
+    package com.example
+    data class $className(
+        val message: String,
+        val timestamp: Long
+    )
+    """
+
+        testCompilation(
+            "$className.kt",
+            sourceContent
+        ) {
+            assertThat(it.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK)
+            it.assertGeneratedFactoryEquals(
+                className,
+                """
+                    package com.example
+                    
+                    import fr.xgouchet.elmyr.Forge
+                    import fr.xgouchet.elmyr.ForgeryFactory
+                    import kotlin.Long
+                    import kotlin.String
+                    
+                    public class FooForgeryFactory : ForgeryFactory<Foo> {
+                        override fun getForgery(forge: Forge): Foo {
+                            val message: String = forge.aString()
+                            val timestamp: Long = forge.aLong()
+                            return Foo(message = message, timestamp = timestamp)
+                        }
+                    }
+                    
+                    """.trimIndent()
+            )
+        }
+    }
+
+    @Test
+    fun processInternalDataClass() {
+        val className = "Foo"
+        val sourceContent = """
+    package com.example
+    internal data class $className(
+        val message: String,
+        val timestamp: Long
+    )
+    """
+
+        testCompilation(
+            "$className.kt",
+            sourceContent
+        ) {
+            assertThat(it.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK)
+            it.assertGeneratedFactoryEquals(
+                className,
+                """
+                    package com.example
+                    
+                    import fr.xgouchet.elmyr.Forge
+                    import fr.xgouchet.elmyr.ForgeryFactory
+                    import kotlin.Long
+                    import kotlin.String
+                    
+                    internal class FooForgeryFactory : ForgeryFactory<Foo> {
+                        override fun getForgery(forge: Forge): Foo {
+                            val message: String = forge.aString()
+                            val timestamp: Long = forge.aLong()
+                            return Foo(message = message, timestamp = timestamp)
+                        }
+                    }
+                    
+                    """.trimIndent()
+            )
+        }
+    }
+
+    @Test
+    fun processNestedDataClass() {
+        val className = "Foo"
+        val parentClassName = "Bar"
+        val sourceContent = """
+    package com.example
+    
+    class $parentClassName {
+        data class $className(
+            val message: String,
+            val timestamp: Long
+        )
+    }
+    """
+
+        testCompilation(
+            "$className.kt",
+            sourceContent
+        ) {
+            assertThat(it.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK)
+            it.assertGeneratedFactoryEquals(
+                className,
+                """
+                    package com.example
+                    
+                    import fr.xgouchet.elmyr.Forge
+                    import fr.xgouchet.elmyr.ForgeryFactory
+                    import kotlin.Long
+                    import kotlin.String
+                    
+                    public class FooForgeryFactory : ForgeryFactory<Bar.Foo> {
+                        override fun getForgery(forge: Forge): Bar.Foo {
+                            val message: String = forge.aString()
+                            val timestamp: Long = forge.aLong()
+                            return Bar.Foo(message = message, timestamp = timestamp)
+                        }
+                    }
+                    
+                    """.trimIndent()
+            )
+        }
+    }
+
+    @Test
+    fun processDataClassWithPrimitiveArguments() {
+        val className = "Spam"
+        val sourceContent = """
+            package com.example
+            data class $className(
+                val s: String,
+                val b: Boolean,
+                val y: Byte,
+                val h: Short,
+                val i: Int,
+                val l: Long,
+                val f: Float,
+                val d: Double,
+                val c: Char
+            )
+    """
+
+        testCompilation(
+            "$className.kt",
+            sourceContent
+        ) {
+            assertThat(it.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK)
+            it.assertGeneratedFactoryEquals(
+                className,
+                """
+                    package com.example
+                    
+                    import fr.xgouchet.elmyr.Forge
+                    import fr.xgouchet.elmyr.ForgeryFactory
+                    import kotlin.Boolean
+                    import kotlin.Byte
+                    import kotlin.Char
+                    import kotlin.Double
+                    import kotlin.Float
+                    import kotlin.Int
+                    import kotlin.Long
+                    import kotlin.Short
+                    import kotlin.String
+                    
+                    public class SpamForgeryFactory : ForgeryFactory<Spam> {
+                        override fun getForgery(forge: Forge): Spam {
+                            val s: String = forge.aString()
+                            val b: Boolean = forge.aBool()
+                            val y: Byte = forge.aByte()
+                            val h: Short = forge.aShort()
+                            val i: Int = forge.anInt()
+                            val l: Long = forge.aLong()
+                            val f: Float = forge.aFloat()
+                            val d: Double = forge.aDouble()
+                            val c: Char = forge.aChar()
+                            return Spam(s = s, b = b, y = y, h = h, i = i, l = l, f = f, d = d, c = c)
+                        }
+                    }
+                    
+                    """.trimIndent()
+            )
+        }
+    }
+
+    @Test
+    fun processDataClassWithNullablePrimitiveArguments() {
+        val className = "Spam"
+        val sourceContent = """
+            package com.example
+            data class $className(
+                val s: String?,
+                val b: Boolean?,
+                val y: Byte?,
+                val h: Short?,
+                val i: Int?,
+                val l: Long?,
+                val f: Float?,
+                val d: Double?,
+                val c: Char?
+            )
+    """
+
+        testCompilation(
+            "$className.kt",
+            sourceContent
+        ) {
+            assertThat(it.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK)
+            it.assertGeneratedFactoryEquals(
+                className,
+                """
+                    package com.example
+                    
+                    import fr.xgouchet.elmyr.Forge
+                    import fr.xgouchet.elmyr.ForgeryFactory
+                    import kotlin.Boolean
+                    import kotlin.Byte
+                    import kotlin.Char
+                    import kotlin.Double
+                    import kotlin.Float
+                    import kotlin.Int
+                    import kotlin.Long
+                    import kotlin.Short
+                    import kotlin.String
+                    
+                    public class SpamForgeryFactory : ForgeryFactory<Spam> {
+                        override fun getForgery(forge: Forge): Spam {
+                            val s: String? = forge.aNullable { aString() }
+                            val b: Boolean? = forge.aNullable { aBool() }
+                            val y: Byte? = forge.aNullable { aByte() }
+                            val h: Short? = forge.aNullable { aShort() }
+                            val i: Int? = forge.aNullable { anInt() }
+                            val l: Long? = forge.aNullable { aLong() }
+                            val f: Float? = forge.aNullable { aFloat() }
+                            val d: Double? = forge.aNullable { aDouble() }
+                            val c: Char? = forge.aNullable { aChar() }
+                            return Spam(s = s, b = b, y = y, h = h, i = i, l = l, f = f, d = d, c = c)
+                        }
+                    }
+                    
+                    """.trimIndent()
+            )
+        }
+    }
+
+    @Test
+    fun processDataClassWithEnumArguments() {
+        val className = "Bacon"
+        val sourceContent = """
+            package com.example
+            
+            enum class Day { MON, TUE, WED, THU, FRI, SAT, SUN }
+            
+            data class $className(
+                val d: Day
+            )
+    """
+
+        testCompilation(
+            "$className.kt",
+            sourceContent
+        ) {
+            assertThat(it.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK)
+            it.assertGeneratedFactoryEquals(
+                className,
+                """
+                    package com.example
+                    
+                    import fr.xgouchet.elmyr.Forge
+                    import fr.xgouchet.elmyr.ForgeryFactory
+                    
+                    public class BaconForgeryFactory : ForgeryFactory<Bacon> {
+                        override fun getForgery(forge: Forge): Bacon {
+                            val d: Day = forge.getForgery()
+                            return Bacon(d = d)
+                        }
+                    }
+                    
+                    """.trimIndent()
+            )
+        }
+    }
+
+    @Test
+    fun processDataClassWithSecondaryConst() {
+        val className = "Foo"
+        val sourceContent = """
+            package com.example
+            data class $className(
+                val message: String,
+                val timestamp: Long
+            ) {
+                constructor(obj: Any): this(obj.toString(), 0L)
+            }
+        """.trimIndent()
+
+        testCompilation(
+            "$className.kt",
+            sourceContent
+        ) {
+            assertThat(it.exitCode).isEqualTo(KotlinCompilation.ExitCode.OK)
+
+            it.assertGeneratedFactoryEquals(
+                className,
+                """
+                    package com.example
+                    
+                    import fr.xgouchet.elmyr.Forge
+                    import fr.xgouchet.elmyr.ForgeryFactory
+                    import kotlin.Long
+                    import kotlin.String
+                    
+                    public class FooForgeryFactory : ForgeryFactory<Foo> {
+                        override fun getForgery(forge: Forge): Foo {
+                            val message: String = forge.aString()
+                            val timestamp: Long = forge.aLong()
+                            return Foo(message = message, timestamp = timestamp)
+                        }
+                    }
+                    
+                    """.trimIndent()
+            )
+        }
+    }
+
+    // region Internal
+
+    private fun testCompilation(
+        testSourceFileName: String,
+        testSourceFileContent: String,
+        assert: (KotlinCompilation.Result) -> Unit
+    ) {
+        val testFile = SourceFile.kotlin(testSourceFileName, testSourceFileContent)
+        val compilation = KotlinCompilation().apply {
+            inheritClassPath = true
+            sources = listOf(testFile)
+            jvmTarget = JvmTarget.JVM_17.description
+            symbolProcessorProviders = listOf(ForgerableProcessorProvider())
+        }
+
+        val result = compilation.compile()
+
+        assert(result)
+    }
+
+    private fun KotlinCompilation.Result.assertGeneratedFactoryEquals(
+        sourceClassName: String,
+        expectedContent: String
+    ) {
+        assertThat(sourceFor("${sourceClassName}ForgeryFactory.kt"))
+            .isEqualTo(expectedContent)
+    }
+
+    private fun KotlinCompilation.Result.assertNothingGenerated(
+        sourceClassName: String
+    ) {
+        assertThat(sourceFor("${sourceClassName}ForgeryFactory.kt"))
+            .isNull()
+    }
+
+    private fun KotlinCompilation.Result.sourceFor(fileName: String): String? {
+        val kspGeneratedSources = getKspGeneratedSources()
+        kspGeneratedSources.forEach {
+            println("Found generated source ${it.name} at ${it.path}")
+        }
+        return kspGeneratedSources.find { it.name == fileName }
+            ?.readText()
+    }
+
+    private fun KotlinCompilation.Result.getKspGeneratedSources(): List<File> {
+        val workingDir = outputDirectory.parentFile
+        val kspWorkingDir = workingDir.resolve("ksp")
+        val kspGeneratedDir = kspWorkingDir.resolve("sources")
+        val kotlinGeneratedDir = kspGeneratedDir.resolve("kotlin")
+        val javaGeneratedDir = kspGeneratedDir.resolve("java")
+        return kotlinGeneratedDir.walk().toList() +
+            javaGeneratedDir.walk().toList()
+    }
+
+    // endregion
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 12374f3..4413894 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -4,5 +4,6 @@ include(":inject")
 include(":junit4")
 include(":junit5")
 include(":jvm")
+include(":ksp")
 include(":semantics")
 include(":spek")