From fc4be35360c437e89e023ebcbedece8a702a214d Mon Sep 17 00:00:00 2001
From: Michael Rittmeister <michael@rittmeister.in>
Date: Tue, 12 Sep 2023 23:33:07 +0200
Subject: [PATCH] Updates for final release - use codegen.kt within codegen.kt
 - Correctly set JVM targets - Stop publishing Gradle metadata - Add
 addAnnotation to Annotatable.Builder instead - No longer mark
 SubSpecDelegateProvider as @CodeGenInternal

---
 .idea/compiler.xml                            |  2 +-
 .idea/jarRepositories.xml                     |  5 ++
 .idea/jsonSchemas.xml                         | 25 +++++++++
 build.gradle.kts                              |  5 ++
 buildSrc/src/main/kotlin/JVMTarget.kt         | 35 ++++++++++++
 .../main/kotlin/kord-publishing.gradle.kts    |  9 +++-
 code-processor/build.gradle.kts               |  2 +-
 .../builder_functions/BuilderVisitor.kt       | 10 ++--
 .../InlinedConstructorGenerator.kt            | 33 +++++++-----
 .../src/main/kotlin/reification/Reifyer.kt    | 12 +++--
 .../src/main/kotlin/utils/ContractHelper.kt   | 10 ++--
 .../src/main/kotlin/utils/KSPUtils.kt         | 11 ----
 code-processor/src/main/kotlin/utils/Names.kt | 23 +++++---
 .../src/main/kotlin/utils/ParameterHelpers.kt |  3 +-
 gradle/libs.versions.toml                     |  7 +++
 .../kotlinpoet/AnnotationSpecBuilders.kt      | 54 +++----------------
 .../AnnotationSpecBuildersReified.kt          |  9 +---
 .../kotlin/builders/AnnotationSpecBuilders.kt | 10 +---
 .../kotlin/delegate/SubSpecDelegate.kt        |  4 +-
 ksp-processor/build.gradle.kts                |  8 +++
 .../kotlin/generator/AccessorFunctions.kt     | 50 ++++++++---------
 .../generator/DataClassRepresentation.kt      | 35 ++++++------
 .../main/kotlin/generator/FactoryFunction.kt  | 24 +++++----
 .../src/main/kotlin/generator/Generator.kt    | 18 +++----
 ksp/build.gradle.kts                          | 18 +++++++
 ksp/src/main/kotlin/TypeResolvers.kt          |  3 +-
 .../kotlin/annotations/ProcessorAnnotation.kt |  1 +
 27 files changed, 248 insertions(+), 178 deletions(-)
 create mode 100644 .idea/jsonSchemas.xml
 create mode 100644 buildSrc/src/main/kotlin/JVMTarget.kt

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index 312bf2e..61a9130 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="20" />
+    <bytecodeTargetLevel target="1.8" />
   </component>
 </project>
\ No newline at end of file
diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
index e40fc1c..051dd42 100644
--- a/.idea/jarRepositories.xml
+++ b/.idea/jarRepositories.xml
@@ -21,5 +21,10 @@
       <option name="name" value="Gradle Central Plugin Repository" />
       <option name="url" value="https://plugins.gradle.org/m2" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven" />
+      <option name="name" value="maven" />
+      <option name="url" value="https://oss.sonatype.org/content/repositories/snapshots/" />
+    </remote-repository>
   </component>
 </project>
\ No newline at end of file
diff --git a/.idea/jsonSchemas.xml b/.idea/jsonSchemas.xml
new file mode 100644
index 0000000..be0105b
--- /dev/null
+++ b/.idea/jsonSchemas.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JsonSchemaMappingsProjectConfiguration">
+    <state>
+      <map>
+        <entry key="GitHub Workflow">
+          <value>
+            <SchemaInfo>
+              <option name="name" value="GitHub Workflow" />
+              <option name="relativePathToSchema" value="https://json.schemastore.org/github-workflow.json" />
+              <option name="applicationDefined" value="true" />
+              <option name="patterns">
+                <list>
+                  <Item>
+                    <option name="path" value=".github/workflows/docs.yml" />
+                  </Item>
+                </list>
+              </option>
+            </SchemaInfo>
+          </value>
+        </entry>
+      </map>
+    </state>
+  </component>
+</project>
\ No newline at end of file
diff --git a/build.gradle.kts b/build.gradle.kts
index 4cdff67..b62e01a 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -9,9 +9,14 @@ allprojects {
 
     repositories {
         mavenCentral()
+        maven("https://oss.sonatype.org/content/repositories/snapshots/")
     }
 }
 
+subprojects {
+    configureJVMTarget()
+}
+
 tasks {
     dokkaHtmlMultiModule {
         outputDirectory = layout.projectDirectory.dir("docs/api")
diff --git a/buildSrc/src/main/kotlin/JVMTarget.kt b/buildSrc/src/main/kotlin/JVMTarget.kt
new file mode 100644
index 0000000..2cf2773
--- /dev/null
+++ b/buildSrc/src/main/kotlin/JVMTarget.kt
@@ -0,0 +1,35 @@
+import gradle.kotlin.dsl.accessors._8d1ef46afdac024fc616c6e49cc7c389.java
+import org.gradle.api.JavaVersion
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.the
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+import org.gradle.kotlin.dsl.*
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
+
+fun Project.configureJVMTarget() {
+    plugins.withId("org.gradle.java") {
+        java {
+            sourceCompatibility = JavaVersion.VERSION_1_8
+        }
+    }
+
+    plugins.withId("org.jetbrains.kotlin.jvm") {
+        the<KotlinJvmProjectExtension>().compilerOptions {
+            jvmTarget = JvmTarget.JVM_1_8
+        }
+    }
+
+    plugins.withId("org.jetbrains.kotlin.multiplatform") {
+        the<KotlinMultiplatformExtension>().targets {
+            withType<KotlinJvmTarget>().configureEach {
+                compilations.all {
+                    compilerOptions.configure {
+                        jvmTarget = JvmTarget.JVM_1_8
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/buildSrc/src/main/kotlin/kord-publishing.gradle.kts b/buildSrc/src/main/kotlin/kord-publishing.gradle.kts
index 87a6a60..bc2fe40 100644
--- a/buildSrc/src/main/kotlin/kord-publishing.gradle.kts
+++ b/buildSrc/src/main/kotlin/kord-publishing.gradle.kts
@@ -47,7 +47,7 @@ tasks {
 
 mavenPublishing {
     publishToMavenCentral()
-    if (false) {
+    if (!System.getenv("ORG_GRADLE_PROJECT_signingInMemoryKey").isNullOrBlank()) {
         signAllPublications()
     }
 
@@ -82,6 +82,13 @@ plugins.withId("org.jetbrains.kotlin.multiplatform") {
 
         withType<PublishToMavenRepository> {
             enabled = name == "publishMavenPublicationToMavenRepository"
+                || name == "publishMavenPublicationToMavenCentralRepository"
+        }
+
+        // Theoretically, this makes us loose information, however, that information is not relevant, since this is
+        // pretty much only a JVM lib targeting JVM 1.8 (so validation of that is unnecessary)
+        withType<GenerateModuleMetadata> {
+            enabled = false
         }
     }
 }
diff --git a/code-processor/build.gradle.kts b/code-processor/build.gradle.kts
index 67ffa66..12c1a41 100644
--- a/code-processor/build.gradle.kts
+++ b/code-processor/build.gradle.kts
@@ -9,7 +9,7 @@ kotlin {
 }
 
 dependencies {
-    implementation(libs.kotlinpoet)
+    implementation(libs.codegen.kotlinpoet)
     implementation(libs.kotlinpoet.ksp)
     implementation(libs.ksp.api)
     implementation(projects.kspAnnotations)
diff --git a/code-processor/src/main/kotlin/builder_functions/BuilderVisitor.kt b/code-processor/src/main/kotlin/builder_functions/BuilderVisitor.kt
index 740dc7f..2d18e40 100644
--- a/code-processor/src/main/kotlin/builder_functions/BuilderVisitor.kt
+++ b/code-processor/src/main/kotlin/builder_functions/BuilderVisitor.kt
@@ -10,6 +10,9 @@ import com.squareup.kotlinpoet.ksp.writeTo
 import dev.kord.codegen.generator.packageName
 import dev.kord.codegen.generator.utils.*
 import dev.kord.codegen.generator.visitors.VisitorBase
+import dev.kord.codegen.kotlinpoet.AnnotationSpec
+import dev.kord.codegen.kotlinpoet.LambdaTypeName
+import dev.kord.codegen.kotlinpoet.TypeAliasSpec
 import dev.kord.codegen.ksp.companionDeclaration
 
 /**
@@ -46,12 +49,11 @@ object BuilderVisitor : VisitorBase() {
 
         val addBuilder = RunOnceFunction<FileSpec.Builder, String> { file, builderName ->
             file.optInForContracts()
-            val alias = LambdaTypeName.get(
+            val alias = LambdaTypeName(
                 classDeclaration.toClassName().nestedClass("Builder"),
                 returnType = UNIT
-            ).copy(annotations = listOf(AnnotationSpec.builder(CODEGEN_DSL).build()))
-            val typeAliasSpec =
-                TypeAliasSpec.builder(builderName, alias).build()
+            ).copy(annotations = listOf(AnnotationSpec(CODEGEN_DSL)))
+            val typeAliasSpec = TypeAliasSpec(builderName, alias)
             file.members.add(0, typeAliasSpec)
         }
 
diff --git a/code-processor/src/main/kotlin/constructor_inliner/InlinedConstructorGenerator.kt b/code-processor/src/main/kotlin/constructor_inliner/InlinedConstructorGenerator.kt
index a2b0900..a620dce 100644
--- a/code-processor/src/main/kotlin/constructor_inliner/InlinedConstructorGenerator.kt
+++ b/code-processor/src/main/kotlin/constructor_inliner/InlinedConstructorGenerator.kt
@@ -5,9 +5,12 @@ package dev.kord.codegen.generator.constructor_inliner
 import com.google.devtools.ksp.symbol.KSValueParameter
 import com.squareup.kotlinpoet.*
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.jvm.jvmWildcard
 import com.squareup.kotlinpoet.ksp.toClassName
 import dev.kord.codegen.generator.utils.*
 import dev.kord.codegen.generator.builder_functions.FactoryFunction
+import dev.kord.codegen.kotlinpoet.FunSpec
+import dev.kord.codegen.kotlinpoet.withControlFlow
 
 context(FactoryFunction)
 private fun FunSpec.Builder.getValueParametersList(packageName: String): CodeBlock {
@@ -72,16 +75,16 @@ fun FactoryFunction.generateInlinedConstructorWithNameDelegate(
     returns(SUB_SPEC_DELEGATE_PROVIDER.parameterizedBy(specType.toClassName()))
 
     val code = buildCodeBlock {
-        beginControlFlow("return·%M { %L ->", PRODUCE_BY_NAME, constructor.nameProperty)
-        addStatement(
-            "%L(%L).also(::%L)",
-            builderFunctionName.takeIf { !constructor.useQualifiedName }
-                ?.escapeIfNecessary()
-                ?: "$packageName.$builderFunctionName",
-            valueParameterList,
-            constructor.functionName,
-        )
-        endControlFlow()
+        withControlFlow("return·%M { %L ->", PRODUCE_BY_NAME, constructor.nameProperty) {
+            addStatement(
+                "%L(%L).also(::%L)",
+                builderFunctionName.takeIf { !constructor.useQualifiedName }
+                    ?.escapeIfNecessary()
+                    ?: "$packageName.$builderFunctionName",
+                valueParameterList,
+                constructor.functionName,
+            )
+        }
     }
 
     addCode(code)
@@ -105,8 +108,12 @@ private fun FactoryFunction.generateInlinedConstructor(
     }
     val builderParameter = getBuilderParameter(packageName)
 
-    return FunSpec.builder(name).apply {
-        receiver(constructor.forClass.toClassName())
+    return FunSpec(name) {
+        if (constructor.forClass.declaration.typeParameters.isNotEmpty()) {
+            receiver(constructor.forClass.toClassName().parameterizedBy(STAR))
+        } else {
+            receiver(constructor.forClass.toClassName())
+        }
 
         if (hasBuilder) {
             if (!noinline) {
@@ -120,5 +127,5 @@ private fun FactoryFunction.generateInlinedConstructor(
         if (hasBuilder) {
             addParameter(builderParameter)
         }
-    }.build()
+    }
 }
diff --git a/code-processor/src/main/kotlin/reification/Reifyer.kt b/code-processor/src/main/kotlin/reification/Reifyer.kt
index bc99423..727e5da 100644
--- a/code-processor/src/main/kotlin/reification/Reifyer.kt
+++ b/code-processor/src/main/kotlin/reification/Reifyer.kt
@@ -8,6 +8,8 @@ import com.squareup.kotlinpoet.ksp.*
 import dev.kord.codegen.generator.utils.addAnnotationsFromFunction
 import dev.kord.codegen.generator.utils.toParameterSpec
 import dev.kord.codegen.generator.utils.toTypeParameterResolver
+import dev.kord.codegen.kotlinpoet.CodeBlock
+import dev.kord.codegen.kotlinpoet.FunSpec
 import java.lang.reflect.Modifier
 import kotlin.reflect.KClass
 
@@ -32,7 +34,7 @@ val TYPE_NAME_OF = MemberName("com.squareup.kotlinpoet", "typeNameOf")
 fun MaybeReifiableFunction.reify(): FunSpec {
     val nameAllocator = NameAllocator()
 
-    return FunSpec.builder(simpleName.asString()).apply {
+    return FunSpec(simpleName.asString()) {
         addModifiers(KModifier.INLINE)
         // If the parent of the function is a class,
         // we need to define the reified function as an extension of that class
@@ -55,7 +57,9 @@ fun MaybeReifiableFunction.reify(): FunSpec {
             }
         } else if (extensionReceiver != null) {
             // otherwise, just use the receiver of the actual function
-            receiver(extensionReceiver.toTypeName())
+            if (!extensionReceiver.resolve().isError) {
+                receiver(extensionReceiver.toTypeName())
+            }
         }
 
         val typeVariableResolver = typeVariables.toTypeParameterResolver()
@@ -91,7 +95,7 @@ fun MaybeReifiableFunction.reify(): FunSpec {
                     else -> error("Unreifiable type: ${it.type}")
                 }
             } else {
-                buildCodeBlock {
+                CodeBlock {
                     if (KModifier.VARARG in it.modifiers) {
                         add("%N·=·", it)
                     }
@@ -102,7 +106,7 @@ fun MaybeReifiableFunction.reify(): FunSpec {
 
         addAnnotationsFromFunction(this@reify)
         addCode("return·%N(%L)", simpleName.asString(), valueParameters)
-    }.build()
+    }
 }
 
 @PublishedApi
diff --git a/code-processor/src/main/kotlin/utils/ContractHelper.kt b/code-processor/src/main/kotlin/utils/ContractHelper.kt
index 96eb291..9b04343 100644
--- a/code-processor/src/main/kotlin/utils/ContractHelper.kt
+++ b/code-processor/src/main/kotlin/utils/ContractHelper.kt
@@ -2,8 +2,8 @@ package dev.kord.codegen.generator.utils
 
 import com.squareup.kotlinpoet.*
 import com.squareup.kotlinpoet.MemberName.Companion.member
+import dev.kord.codegen.kotlinpoet.addAnnotation
 import kotlin.contracts.ExperimentalContracts
-import kotlin.contracts.InvocationKind
 
 private val OPT_IN = ClassName("kotlin", "OptIn")
 private val CONTRACT = MemberName("kotlin.contracts", "contract")
@@ -26,9 +26,7 @@ fun FunSpec.Builder.addCallsInPlaceExactlyOnce(builderProperty: ParameterSpec) {
  * Adds the required opt-in for [ExperimentalContracts].
  */
 fun Annotatable.Builder<*>.optInForContracts() {
-    addAnnotation(
-        AnnotationSpec.builder(OPT_IN)
-            .addMember("%T::class", ClassName("kotlin.contracts", "ExperimentalContracts"))
-            .build()
-    )
+    addAnnotation(OPT_IN) {
+        addMember("%T::class", ClassName("kotlin.contracts", "ExperimentalContracts"))
+    }
 }
diff --git a/code-processor/src/main/kotlin/utils/KSPUtils.kt b/code-processor/src/main/kotlin/utils/KSPUtils.kt
index 16820fd..6a46a48 100644
--- a/code-processor/src/main/kotlin/utils/KSPUtils.kt
+++ b/code-processor/src/main/kotlin/utils/KSPUtils.kt
@@ -37,17 +37,6 @@ fun KSValueParameter.toParameterSpec(typeParamResolver: TypeParameterResolver =
         }
         .build()
 
-fun KSFunctionDeclaration.toFunSpec(typeParamResolver: TypeParameterResolver = TypeParameterResolver.EMPTY) =
-    FunSpec.builder(simpleName.asString())
-        .apply {
-            val declarationTypeResolver = parentDeclaration!!.typeParameters.toTypeParameterResolver()
-            val functionResolver = typeParameters.toTypeParameterResolver(declarationTypeResolver)
-            addParameters(this@toFunSpec.parameters.map { it.toParameterSpec(functionResolver) })
-            addModifiers(this@toFunSpec.modifiers.mapNotNull(Modifier::toKModifier))
-            returns(ANY)
-            returns(returnType!!.toTypeName(parentDeclaration!!.typeParameters.toTypeParameterResolver(typeParamResolver)))
-        }.build()
-
 private val KSValueParameter.modifiers: Set<KModifier>
     get() = buildSet {
         if (this is KSModifierListOwner) {
diff --git a/code-processor/src/main/kotlin/utils/Names.kt b/code-processor/src/main/kotlin/utils/Names.kt
index 6897220..8e1666c 100644
--- a/code-processor/src/main/kotlin/utils/Names.kt
+++ b/code-processor/src/main/kotlin/utils/Names.kt
@@ -1,9 +1,20 @@
+@file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
+@file:OptIn(CodeGenInternal::class)
+
 package dev.kord.codegen.generator.utils
 
-import com.squareup.kotlinpoet.ClassName
-import com.squareup.kotlinpoet.MemberName
+import com.squareup.kotlinpoet.asClassName
+import dev.kord.codegen.kotlinpoet.CodeGenDsl
+import dev.kord.codegen.kotlinpoet.CodeGenInternal
+import dev.kord.codegen.kotlinpoet.asMemberName
+import dev.kord.codegen.kotlinpoet.delegate.SubSpecDelegateProvider
+import dev.kord.codegen.kotlinpoet.delegate.produceByName
+import dev.kord.codegen.kotlinpoet.emptyCodeBlock
+import kotlin.reflect.KFunction
+
+private val produceByName: KFunction<SubSpecDelegateProvider<String>> = ::produceByName
 
-val CODEGEN_DSL = ClassName("dev.kord.codegen.kotlinpoet", "CodeGenDsl")
-val EMPTY_CODE_BLOCK = MemberName("dev.kord.codegen.kotlinpoet", "emptyCodeBlock")
-val PRODUCE_BY_NAME = MemberName("dev.kord.codegen.kotlinpoet.delegate", "produceByName")
-val SUB_SPEC_DELEGATE_PROVIDER = ClassName("dev.kord.codegen.kotlinpoet.delegate", "SubSpecDelegateProvider")
+val CODEGEN_DSL = CodeGenDsl::class.asClassName()
+val EMPTY_CODE_BLOCK = ::emptyCodeBlock.asMemberName()
+val PRODUCE_BY_NAME = produceByName.asMemberName()
+val SUB_SPEC_DELEGATE_PROVIDER = SubSpecDelegateProvider::class.asClassName()
diff --git a/code-processor/src/main/kotlin/utils/ParameterHelpers.kt b/code-processor/src/main/kotlin/utils/ParameterHelpers.kt
index c2280c0..e4593a7 100644
--- a/code-processor/src/main/kotlin/utils/ParameterHelpers.kt
+++ b/code-processor/src/main/kotlin/utils/ParameterHelpers.kt
@@ -1,6 +1,7 @@
 package dev.kord.codegen.generator.utils
 
 import com.squareup.kotlinpoet.*
+import dev.kord.codegen.kotlinpoet.CodeBlock
 
 /**
  * Maps an [Iterable] of [ParameterSpecs][ParameterSpec] to a [CodeBlock], representing the value parameter list
@@ -8,7 +9,7 @@ import com.squareup.kotlinpoet.*
  */
 fun Iterable<ParameterSpec>.mapToValueParameterList() =
     map {
-        buildCodeBlock {
+        CodeBlock {
             // If the parameter is a varag, we need to spread it, which can be done
             // using the spread operator or using named arguments
             // however using named arguments works regardless of the position of the argument
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index a3813c7..250e6df 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -3,11 +3,18 @@ kotlin = "1.9.10"
 kotlinpoet = "1.14.2"
 ksp = "1.9.10-1.0.13"
 
+# The compiled binary of codegen.kt we use to compile codegen.kt itself
+codegen-kt = "main-SNAPSHOT"
+
 [libraries]
 ksp-api = { group = "com.google.devtools.ksp", name = "symbol-processing-api", version.ref = "ksp" }
 kotlinpoet = { group = "com.squareup", name = "kotlinpoet", version.ref = "kotlinpoet" }
 kotlinpoet-ksp = { group = "com.squareup", name = "kotlinpoet-ksp", version.ref = "kotlinpoet" }
 
+codegen-kotlinpoet = { group = "dev.kord.codegen", name = "kotlinpoet", version = "main-20230912.212936-5" }
+codegen-ksp = { group = "dev.kord.codegen", name = "ksp", version = "main-20230912.211940-5" }
+codegen-ksp-processor = { group = "dev.kord.codegen", name = "ksp-processor", version = "main-20230912.211940-7" }
+
 mockk = { group = "io.mockk", name = "mockk", version = "1.13.7" }
 
 kotlin-plugin = { group = "org.jetbrains.kotlin", name = "kotlin-gradle-plugin", version.ref = "kotlin" }
diff --git a/kotlinpoet/build/generated/ksp/generationSource/generationSourceMain/kotlin/dev/kord/codegen/kotlinpoet/AnnotationSpecBuilders.kt b/kotlinpoet/build/generated/ksp/generationSource/generationSourceMain/kotlin/dev/kord/codegen/kotlinpoet/AnnotationSpecBuilders.kt
index e639e22..42a905b 100644
--- a/kotlinpoet/build/generated/ksp/generationSource/generationSourceMain/kotlin/dev/kord/codegen/kotlinpoet/AnnotationSpecBuilders.kt
+++ b/kotlinpoet/build/generated/ksp/generationSource/generationSourceMain/kotlin/dev/kord/codegen/kotlinpoet/AnnotationSpecBuilders.kt
@@ -2,12 +2,11 @@
 
 package dev.kord.codegen.kotlinpoet
 
+import com.squareup.kotlinpoet.Annotatable
 import com.squareup.kotlinpoet.AnnotationSpec
 import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.DelicateKotlinPoetApi
-import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.ParameterizedTypeName
-import com.squareup.kotlinpoet.TypeSpec
 import javax.lang.model.element.AnnotationMirror
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind.EXACTLY_ONCE
@@ -16,59 +15,22 @@ import kotlin.reflect.KClass
 
 @DelicateKotlinPoetApi(message =
     "Java reflection APIs don't give complete information on Kotlin types. Consider using the kotlinpoet-metadata APIs instead.")
-public fun TypeSpec.Builder.addAnnotation(`annotation`: Annotation, includeDefaultValues: Boolean =
-    false): AnnotationSpec = AnnotationSpec(`annotation`,
+public fun Annotatable.Builder<*>.addAnnotation(`annotation`: Annotation,
+    includeDefaultValues: Boolean = false): AnnotationSpec = AnnotationSpec(`annotation`,
     includeDefaultValues).also(::addAnnotation)
 
 @DelicateKotlinPoetApi(message =
     "Mirror APIs don't give complete information on Kotlin types. Consider using the kotlinpoet-metadata APIs instead.")
-public fun TypeSpec.Builder.addAnnotation(`annotation`: AnnotationMirror): AnnotationSpec =
+public fun Annotatable.Builder<*>.addAnnotation(`annotation`: AnnotationMirror): AnnotationSpec =
     AnnotationSpec(`annotation`).also(::addAnnotation)
 
-public inline fun TypeSpec.Builder.addAnnotation(type: ClassName, block: AnnotationSpecBuilderScope
-    = {}): AnnotationSpec {
-  contract { callsInPlace(block, EXACTLY_ONCE) }
-  return AnnotationSpec(type, block).also(::addAnnotation)
-}
-
-public inline fun TypeSpec.Builder.addAnnotation(type: ParameterizedTypeName,
-    block: AnnotationSpecBuilderScope = {}): AnnotationSpec {
-  contract { callsInPlace(block, EXACTLY_ONCE) }
-  return AnnotationSpec(type, block).also(::addAnnotation)
-}
-
-@DelicateKotlinPoetApi(message =
-    "Java reflection APIs don't give complete information on Kotlin types. Consider using the kotlinpoet-metadata APIs instead.")
-public inline fun TypeSpec.Builder.addAnnotation(type: Class<out Annotation>,
-    block: AnnotationSpecBuilderScope = {}): AnnotationSpec {
-  contract { callsInPlace(block, EXACTLY_ONCE) }
-  return AnnotationSpec(type, block).also(::addAnnotation)
-}
-
-public inline fun TypeSpec.Builder.addAnnotation(type: KClass<out Annotation>,
+public inline fun Annotatable.Builder<*>.addAnnotation(type: ClassName,
     block: AnnotationSpecBuilderScope = {}): AnnotationSpec {
   contract { callsInPlace(block, EXACTLY_ONCE) }
   return AnnotationSpec(type, block).also(::addAnnotation)
 }
 
-@DelicateKotlinPoetApi(message =
-    "Java reflection APIs don't give complete information on Kotlin types. Consider using the kotlinpoet-metadata APIs instead.")
-public fun FileSpec.Builder.addAnnotation(`annotation`: Annotation, includeDefaultValues: Boolean =
-    false): AnnotationSpec = AnnotationSpec(`annotation`,
-    includeDefaultValues).also(::addAnnotation)
-
-@DelicateKotlinPoetApi(message =
-    "Mirror APIs don't give complete information on Kotlin types. Consider using the kotlinpoet-metadata APIs instead.")
-public fun FileSpec.Builder.addAnnotation(`annotation`: AnnotationMirror): AnnotationSpec =
-    AnnotationSpec(`annotation`).also(::addAnnotation)
-
-public inline fun FileSpec.Builder.addAnnotation(type: ClassName, block: AnnotationSpecBuilderScope
-    = {}): AnnotationSpec {
-  contract { callsInPlace(block, EXACTLY_ONCE) }
-  return AnnotationSpec(type, block).also(::addAnnotation)
-}
-
-public inline fun FileSpec.Builder.addAnnotation(type: ParameterizedTypeName,
+public inline fun Annotatable.Builder<*>.addAnnotation(type: ParameterizedTypeName,
     block: AnnotationSpecBuilderScope = {}): AnnotationSpec {
   contract { callsInPlace(block, EXACTLY_ONCE) }
   return AnnotationSpec(type, block).also(::addAnnotation)
@@ -76,13 +38,13 @@ public inline fun FileSpec.Builder.addAnnotation(type: ParameterizedTypeName,
 
 @DelicateKotlinPoetApi(message =
     "Java reflection APIs don't give complete information on Kotlin types. Consider using the kotlinpoet-metadata APIs instead.")
-public inline fun FileSpec.Builder.addAnnotation(type: Class<out Annotation>,
+public inline fun Annotatable.Builder<*>.addAnnotation(type: Class<out Annotation>,
     block: AnnotationSpecBuilderScope = {}): AnnotationSpec {
   contract { callsInPlace(block, EXACTLY_ONCE) }
   return AnnotationSpec(type, block).also(::addAnnotation)
 }
 
-public inline fun FileSpec.Builder.addAnnotation(type: KClass<out Annotation>,
+public inline fun Annotatable.Builder<*>.addAnnotation(type: KClass<out Annotation>,
     block: AnnotationSpecBuilderScope = {}): AnnotationSpec {
   contract { callsInPlace(block, EXACTLY_ONCE) }
   return AnnotationSpec(type, block).also(::addAnnotation)
diff --git a/kotlinpoet/build/generated/ksp/generationSource/generationSourceMain/kotlin/dev/kord/codegen/kotlinpoet/AnnotationSpecBuildersReified.kt b/kotlinpoet/build/generated/ksp/generationSource/generationSourceMain/kotlin/dev/kord/codegen/kotlinpoet/AnnotationSpecBuildersReified.kt
index b3065b7..aaa84fc 100644
--- a/kotlinpoet/build/generated/ksp/generationSource/generationSourceMain/kotlin/dev/kord/codegen/kotlinpoet/AnnotationSpecBuildersReified.kt
+++ b/kotlinpoet/build/generated/ksp/generationSource/generationSourceMain/kotlin/dev/kord/codegen/kotlinpoet/AnnotationSpecBuildersReified.kt
@@ -1,15 +1,10 @@
 package dev.kord.codegen.kotlinpoet
 
+import com.squareup.kotlinpoet.Annotatable
 import com.squareup.kotlinpoet.AnnotationSpec
-import com.squareup.kotlinpoet.FileSpec
-import com.squareup.kotlinpoet.TypeSpec
 import com.squareup.kotlinpoet.asClassName
 import kotlin.Annotation
 
-public inline fun <reified T : Annotation> TypeSpec.Builder.addAnnotation(noinline
-    block: AnnotationSpecBuilderScope = {}): AnnotationSpec = addAnnotation(T::class.asClassName(),
-    block)
-
-public inline fun <reified T : Annotation> FileSpec.Builder.addAnnotation(noinline
+public inline fun <reified T : Annotation> Annotatable.Builder<*>.addAnnotation(noinline
     block: AnnotationSpecBuilderScope = {}): AnnotationSpec = addAnnotation(T::class.asClassName(),
     block)
diff --git a/kotlinpoet/src/commonMain/kotlin/builders/AnnotationSpecBuilders.kt b/kotlinpoet/src/commonMain/kotlin/builders/AnnotationSpecBuilders.kt
index a6b24b8..729c4c4 100644
--- a/kotlinpoet/src/commonMain/kotlin/builders/AnnotationSpecBuilders.kt
+++ b/kotlinpoet/src/commonMain/kotlin/builders/AnnotationSpecBuilders.kt
@@ -1,15 +1,9 @@
 @file:InlineConstructor(
-    forClass = TypeSpec.Builder::class,
-    functionName = "addAnnotation"
-)
-
-@file:InlineConstructor(
-    forClass = FileSpec.Builder::class,
+    forClass = Annotatable.Builder::class,
     functionName = "addAnnotation"
 )
 
 package dev.kord.codegen.kotlinpoet.builders
 
-import com.squareup.kotlinpoet.FileSpec
-import com.squareup.kotlinpoet.TypeSpec
+import com.squareup.kotlinpoet.Annotatable
 import dev.kord.codegen.ksp.annotations.InlineConstructor
diff --git a/kotlinpoet/src/commonMain/kotlin/delegate/SubSpecDelegate.kt b/kotlinpoet/src/commonMain/kotlin/delegate/SubSpecDelegate.kt
index 23b64d6..de79fbb 100644
--- a/kotlinpoet/src/commonMain/kotlin/delegate/SubSpecDelegate.kt
+++ b/kotlinpoet/src/commonMain/kotlin/delegate/SubSpecDelegate.kt
@@ -1,6 +1,5 @@
 package dev.kord.codegen.kotlinpoet.delegate
 
-import dev.kord.codegen.kotlinpoet.CodeGenInternal
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 
@@ -20,8 +19,7 @@ import kotlin.reflect.KProperty
  * val name = "Kodee"
  * ```
  */
-@CodeGenInternal
-public class SubSpecDelegateProvider<T>(private val creator: (String) -> T) {
+public class SubSpecDelegateProvider<T> internal constructor(private val creator: (String) -> T) {
     public operator fun provideDelegate(thisRef: Any?, property: KProperty<*>): ReadOnlyProperty<Any?, T> =
         SubSpecDelegate(creator(property.name))
 }
diff --git a/ksp-processor/build.gradle.kts b/ksp-processor/build.gradle.kts
index 1578ceb..215e9f2 100644
--- a/ksp-processor/build.gradle.kts
+++ b/ksp-processor/build.gradle.kts
@@ -3,7 +3,15 @@ plugins {
     `kord-publishing`
 }
 
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-Xcontext-receivers")
+    }
+}
+
 dependencies {
     implementation(libs.ksp.api)
     implementation(libs.kotlinpoet.ksp)
+    implementation(libs.codegen.kotlinpoet)
+    implementation(libs.codegen.ksp)
 }
diff --git a/ksp-processor/src/main/kotlin/generator/AccessorFunctions.kt b/ksp-processor/src/main/kotlin/generator/AccessorFunctions.kt
index 70900d9..212f3c2 100644
--- a/ksp-processor/src/main/kotlin/generator/AccessorFunctions.kt
+++ b/ksp-processor/src/main/kotlin/generator/AccessorFunctions.kt
@@ -9,7 +9,9 @@ import com.squareup.kotlinpoet.FunSpec
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import com.squareup.kotlinpoet.asClassName
 import com.squareup.kotlinpoet.ksp.toClassName
+import dev.kord.codegen.kotlinpoet.addFunction
 import dev.kord.codegen.ksp.processor.GET_ANNOTATIONS_BY_TYPE
+import dev.kord.codegen.ksp.processor.GET_ANNOTATION_BY_TYPE
 
 fun ProcessingContext.accessorFunction() {
     val dataClass = ClassName(packageName, declaration.simpleName.asString())
@@ -35,30 +37,28 @@ private fun KSClassDeclaration.accessorFunction(dataClass: ClassName, file: File
         it.annotationType.resolve().declaration.qualifiedName!!.asString() == Repeatable::class.qualifiedName
     }
 
-    if (repeatable) {
-        val function = FunSpec.builder("get${simpleName.asString()}s")
-            .returns(Sequence::class.asClassName().parameterizedBy(dataClass))
-            .receiver(KSAnnotated::class.asClassName())
-            .addKdoc(
-                "Returns a [%T] of all [%T] annotations on this [element](%T)",
-                Sequence::class.asClassName(),
-                dataClass,
-                KSAnnotated::class.asClassName()
-            )
-            .addCode("return·%M<%T>()", GET_ANNOTATIONS_BY_TYPE, toClassName())
-            .addCode(".map(%1L.Companion::%1L)", dataClass.simpleName)
-            .build()
-
-        file.addFunction(function)
-    } else {
-        val function = FunSpec.builder("get${simpleName.asString()}")
-            .returns(dataClass)
-            .receiver(KSAnnotated::class.asClassName())
-            .addKdoc("Returns a %T annotation [element](%T)", dataClass, KSAnnotated::class.asClassName())
-            .addCode("return·%M<%T>()", GET_ANNOTATIONS_BY_TYPE, toClassName())
-            .addCode(".let(%1L.Companion::%1L)", dataClass.simpleName)
-            .build()
-
-        file.addFunction(function)
+    with(file) {
+        if (repeatable) {
+            addFunction("get${simpleName.asString()}s") {
+                returns(Sequence::class.asClassName().parameterizedBy(dataClass))
+                receiver(KSAnnotated::class.asClassName())
+                addKdoc(
+                    "Returns a [%T] of all [%T] annotations on this [element](%T)",
+                    Sequence::class.asClassName(),
+                    dataClass,
+                    KSAnnotated::class.asClassName()
+                )
+                addCode("return·%M<%T>()", GET_ANNOTATIONS_BY_TYPE, toClassName())
+                addCode(".map(%1L.Companion::%1L)", dataClass.simpleName)
+            }
+        } else {
+            addFunction("get${simpleName.asString()}") {
+                returns(dataClass)
+                receiver(KSAnnotated::class.asClassName())
+                addKdoc("Returns a %T annotation [element](%T)", dataClass, KSAnnotated::class.asClassName())
+                addCode("return·%M<%T>()", GET_ANNOTATION_BY_TYPE, toClassName())
+                addCode(".let(%1L.Companion::%1L)", dataClass.simpleName)
+            }
+        }
     }
 }
diff --git a/ksp-processor/src/main/kotlin/generator/DataClassRepresentation.kt b/ksp-processor/src/main/kotlin/generator/DataClassRepresentation.kt
index 23cccdc..9e345a9 100644
--- a/ksp-processor/src/main/kotlin/generator/DataClassRepresentation.kt
+++ b/ksp-processor/src/main/kotlin/generator/DataClassRepresentation.kt
@@ -1,16 +1,15 @@
 package dev.kord.codegen.ksp.processor.generator
 
 import com.google.devtools.ksp.getDeclaredProperties
-import com.google.devtools.ksp.processing.KSPLogger
 import com.google.devtools.ksp.symbol.*
 import com.squareup.kotlinpoet.*
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import com.squareup.kotlinpoet.ksp.addOriginatingKSFile
 import com.squareup.kotlinpoet.ksp.toClassName
 import com.squareup.kotlinpoet.ksp.toTypeName
+import dev.kord.codegen.kotlinpoet.*
 import dev.kord.codegen.ksp.processor.NULL_IF_DEFAULT
 import dev.kord.codegen.ksp.processor.PROCESSOR_ANNOTATION
-import java.util.logging.Logger
 
 fun KSType.isMappedAnnotation(rootType: KSClassDeclaration): Boolean {
     val declaration = declaration
@@ -70,7 +69,7 @@ private fun KSClassDeclaration.dataClassSpec(
     packageName: String,
     additionalBuilder: TypeSpec.Builder.() -> Unit = {}
 ): TypeSpec {
-    return TypeSpec.classBuilder(simpleName.asString()).apply {
+    return `class`(simpleName.asString()) {
         addKdoc(
             """Data class representation of [%T].
             |@see Companion.%L
@@ -82,27 +81,25 @@ private fun KSClassDeclaration.dataClassSpec(
             .forEach {
                 addType(it.dataClassSpec(packageName))
             }
+
         addModifiers(KModifier.DATA)
-        val primaryConstructor = FunSpec.constructorBuilder()
-            .addModifiers(KModifier.PRIVATE)
-        this@dataClassSpec.getDeclaredProperties().forEach {
-            val name = it.simpleName.asString()
-            val type = it.dataClassType(this@dataClassSpec)
-            val parameter = ParameterSpec.builder(name, type).build()
-            primaryConstructor.addParameter(parameter)
-            val property = PropertySpec.builder(name, type).apply {
-                initializer("%N", parameter)
+        primaryConstructor {
+            addModifiers(KModifier.PRIVATE)
+            this@dataClassSpec.getDeclaredProperties().forEach {
+                val name = it.simpleName.asString()
+                val type = it.dataClassType(this@dataClassSpec)
+                val parameter = addParameter(name, type) {}
+                this@`class`.addProperty(name, type) {
+                    initializer("%N", parameter)
+                }
             }
-            addProperty(property.build())
         }
-        primaryConstructor(primaryConstructor.build())
         additionalBuilder()
 
-        val companion = TypeSpec.companionObjectBuilder()
-            .addFunction(factoryFunction(packageName))
-            .build()
-        addType(companion)
-    }.build()
+        addCompanionObject {
+            factoryFunction(packageName)
+        }
+    }
 }
 
 
diff --git a/ksp-processor/src/main/kotlin/generator/FactoryFunction.kt b/ksp-processor/src/main/kotlin/generator/FactoryFunction.kt
index 002a505..ea1fde5 100644
--- a/ksp-processor/src/main/kotlin/generator/FactoryFunction.kt
+++ b/ksp-processor/src/main/kotlin/generator/FactoryFunction.kt
@@ -5,20 +5,22 @@ import com.google.devtools.ksp.symbol.KSAnnotation
 import com.google.devtools.ksp.symbol.KSClassDeclaration
 import com.squareup.kotlinpoet.*
 import com.squareup.kotlinpoet.ksp.toClassName
+import dev.kord.codegen.kotlinpoet.addFunction
+import dev.kord.codegen.kotlinpoet.addParameter
+import dev.kord.codegen.kotlinpoet.withControlFlow
 import dev.kord.codegen.ksp.processor.ARGUMENTS
 import dev.kord.codegen.ksp.processor.ARGUMENTS_NOT_NULL
 import dev.kord.codegen.ksp.processor.NULL_IF_DEFAULT
 
-
-fun KSClassDeclaration.factoryFunction(packageName: String): FunSpec {
-    return FunSpec.builder(simpleName.asString()).apply {
+context(TypeSpec.Builder)
+fun KSClassDeclaration.factoryFunction(packageName: String) {
+    addFunction(simpleName.asString()) {
         val type = ClassName(packageName, toClassName().simpleNames)
         addKdoc("Creates an [%T] from an [%T].", type, KSAnnotation::class.asClassName())
-        val param = ParameterSpec.builder("annotation", KSAnnotation::class.asClassName()).build()
-        addParameter(param)
+        val annotation by addParameter<KSAnnotation>()
         returns(type)
 
-        addStatement("val arguments = %N.%M<%T>().%M()", param, ARGUMENTS, toClassName(), ARGUMENTS_NOT_NULL)
+        addStatement("val arguments = %N.%M<%T>().%M()", annotation, ARGUMENTS, toClassName(), ARGUMENTS_NOT_NULL)
         addCode("\n")
         val valueArguments = getDeclaredProperties().map {
             val property = buildCodeBlock {
@@ -40,10 +42,10 @@ fun KSClassDeclaration.factoryFunction(packageName: String): FunSpec {
                 }
 
                 if (it.annotations.any { it.annotationType.resolve().declaration.qualifiedName!!.asString() == NULL_IF_DEFAULT }) {
-                    beginControlFlow(".takeIf")
-                    add("!arguments.isDefault(%T::%L)", toClassName(), it.simpleName.asString())
-                    add("\n")
-                    endControlFlow()
+                    withControlFlow(".takeIf") {
+                        add("!arguments.isDefault(%T::%L)", toClassName(), it.simpleName.asString())
+                        add("\n")
+                    }
                 }
                 add("\n")
             }
@@ -51,5 +53,5 @@ fun KSClassDeclaration.factoryFunction(packageName: String): FunSpec {
             CodeBlock.of("%L", it.simpleName.asString())
         }.joinToString(", ")
         addCode("return·%T(%L)", type, valueArguments)
-    }.build()
+    }
 }
diff --git a/ksp-processor/src/main/kotlin/generator/Generator.kt b/ksp-processor/src/main/kotlin/generator/Generator.kt
index 6a688d4..58c65c2 100644
--- a/ksp-processor/src/main/kotlin/generator/Generator.kt
+++ b/ksp-processor/src/main/kotlin/generator/Generator.kt
@@ -7,7 +7,8 @@ import com.squareup.kotlinpoet.DelicateKotlinPoetApi
 import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.ksp.toClassName
 import com.squareup.kotlinpoet.ksp.writeTo
-import dev.kord.codegen.ksp.processor.PROCESSOR_ANNOTATION
+import dev.kord.codegen.kotlinpoet.FileSpec
+import dev.kord.codegen.ksp.processor.getProcessorAnnotation
 
 data class ProcessingContext(
     val environment: SymbolProcessorEnvironment,
@@ -18,17 +19,16 @@ data class ProcessingContext(
 
 @OptIn(DelicateKotlinPoetApi::class)
 fun SymbolProcessorEnvironment.processAnnotation(declaration: KSClassDeclaration) {
-    val packageName =
-        declaration.annotations.first { it.annotationType.resolve().declaration.qualifiedName?.asString() == PROCESSOR_ANNOTATION }
-            .arguments.first().value as String
-    val fileSpec = FileSpec.builder(packageName, declaration.simpleName.asString()).apply {
+    val packageName = declaration.getProcessorAnnotation().packageName
+    val fileSpec = FileSpec(packageName, declaration.simpleName.asString()) {
         addKotlinDefaultImports(includeJs = false)
         addAnnotation(AnnotationSpec.get(Suppress("DataClassPrivateConstructor")))
         addAliasedImport(declaration.toClassName(), "Annotation")
+
+        val context = ProcessingContext(this@processAnnotation, this, declaration, packageName)
+        context.dataClassRepresentation()
+        context.accessorFunction()
     }
-    val context = ProcessingContext(this, fileSpec, declaration, packageName)
-    context.dataClassRepresentation()
-    context.accessorFunction()
 
-    fileSpec.build().writeTo(codeGenerator, false)
+    fileSpec.writeTo(codeGenerator, false)
 }
diff --git a/ksp/build.gradle.kts b/ksp/build.gradle.kts
index 2dd1b13..f42d297 100644
--- a/ksp/build.gradle.kts
+++ b/ksp/build.gradle.kts
@@ -2,6 +2,7 @@ plugins {
     org.jetbrains.kotlin.jvm
     `jvm-test-suite`
     `kord-publishing`
+    com.google.devtools.ksp
 }
 
 kotlin {
@@ -10,10 +11,19 @@ kotlin {
 
 dependencies {
     api(libs.ksp.api)
+    ksp(libs.codegen.ksp.processor)
     testImplementation(libs.mockk)
     testImplementation(kotlin("test-junit5"))
 }
 
+kotlin {
+    sourceSets {
+        main {
+            kotlin.srcDir("build/generated/ksp/main/kotlin")
+        }
+    }
+}
+
 testing {
     suites {
         named<JvmTestSuite>("test") {
@@ -21,3 +31,11 @@ testing {
         }
     }
 }
+
+tasks {
+    afterEvaluate {
+        named("kspTestKotlin") {
+            dependsOn(jar)
+        }
+    }
+}
diff --git a/ksp/src/main/kotlin/TypeResolvers.kt b/ksp/src/main/kotlin/TypeResolvers.kt
index fffdc21..44937af 100644
--- a/ksp/src/main/kotlin/TypeResolvers.kt
+++ b/ksp/src/main/kotlin/TypeResolvers.kt
@@ -5,6 +5,7 @@ import com.google.devtools.ksp.findActualType
 import com.google.devtools.ksp.getAnnotationsByType
 import com.google.devtools.ksp.processing.Resolver
 import com.google.devtools.ksp.symbol.*
+import dev.kord.codegen.ksp.processor.getProcessorAnnotation
 
 /**
  * Get all symbols with specified annotation.
@@ -36,7 +37,6 @@ public inline fun <reified A : Annotation> KSAnnotated.getAnnotationsByType(): S
  *
  * @see getAnnotationsByType
  */
-@KspExperimental
 public inline fun <reified A : Annotation> KSAnnotated.getAnnotationByType(): KSAnnotation =
     getAnnotationsByType<A>().first()
 
@@ -97,4 +97,3 @@ public val KSReferenceElement.isClassifierReference: Boolean
         is KSParenthesizedReference -> element.isClassifierReference
         else -> error("Unexpected KSReferenceElement: $this")
     }
-
diff --git a/ksp/src/main/kotlin/annotations/ProcessorAnnotation.kt b/ksp/src/main/kotlin/annotations/ProcessorAnnotation.kt
index f59a61b..4c5c46f 100644
--- a/ksp/src/main/kotlin/annotations/ProcessorAnnotation.kt
+++ b/ksp/src/main/kotlin/annotations/ProcessorAnnotation.kt
@@ -36,6 +36,7 @@ import com.google.devtools.ksp.symbol.KSAnnotation
 @MustBeDocumented
 @Retention(AnnotationRetention.SOURCE)
 @Target(AnnotationTarget.ANNOTATION_CLASS)
+@ProcessorAnnotation(packageName = "dev.kord.codegen.ksp.processor")
 public annotation class ProcessorAnnotation(
     val packageName: String
 )