Remove the legacy options (#285)

The `kotshi.createAnnotationsUsingConstructor` and `kotshi.useLegacyDataClassRenderer` options have been removed.
ansman · Dec 29, 2023 · 877fcde · 877fcde
1 parent 6d521ef
commit 877fcde
Show file tree

Hide file tree

Showing 12 changed files with 6 additions and 532 deletions.
diff --git a/.github/workflows/gradle.yml b/.github/workflows/gradle.yml
@@ -16,35 +16,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
-    - uses: actions/setup-java@v2
-      with:
-        distribution: 'zulu'
-        java-version: '19'
-    - uses: gradle/gradle-build-action@v2
-      with:
-        arguments: check --continue --stacktrace -Pkotshi.createAnnotationsUsingConstructor=false
-  testWithAnnotations:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
     - uses: actions/setup-java@v2
       with:
         distribution: 'zulu'
         java-version: '19'
     - uses: gradle/gradle-build-action@v2
       with:
         arguments: check --continue --stacktrace
-  testWithLegacyDataClassRenderer:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-java@v2
-      with:
-        distribution: 'zulu'
-        java-version: '19'
-    - uses: gradle/gradle-build-action@v2
-      with:
-        arguments: check --continue --stacktrace -Pkotshi.useLegacyDataClassRenderer=true
   testOldestSupportedMoshi:
     runs-on: ubuntu-latest
     steps:
@@ -58,7 +36,7 @@ jobs:
         arguments: check --continue --stacktrace -Pkotshi.internal.useLegacyMoshi=true
   deploySnapshot:
     runs-on: ubuntu-latest
-    needs: [test, testWithAnnotations, testWithLegacyDataClassRenderer, testOldestSupportedMoshi]
+    needs: [test, testOldestSupportedMoshi]
     steps:
     - uses: actions/checkout@v2
     - uses: actions/setup-java@v2

diff --git a/README.md b/README.md
@@ -106,69 +106,6 @@ that extends `JsonAdapter` with `@RegisterJsonAdapter` and Kotshi will generate
 
 ### Options
 
-#### `kotshi.createAnnotationsUsingConstructor`
-This option enables a new way of creating annotations instances at runtime. Normally Kotshi uses reflection to create
-the qualifier annotations but as of 1.5.30 of Kotlin you can enable creating annotations by calling the constructor.
-
-This behavior is enabled by default when using language version 1.6 but can be explicitly enabled or disabled using this
-option.
-
-Examples:
-<details open>
-  <summary>KSP</summary>
-
-  ```kotlin
-  ksp {
-    arg("kotshi.createAnnotationsUsingConstructor", "false")
-  }
-  ```
-</details>
-
-
-<details>
-  <summary>KAPT</summary>
-
-  ```kotlin
-  kapt {
-    arguments {
-      arg("kotshi.createAnnotationsUsingConstructor", false)
-    }
-  }
-  ```
-</details>
-
-See more about instantiating annotations here: https://kotlinlang.org/docs/whatsnew1530.html#instantiation-of-annotation-classes
-
-#### `kotshi.useLegacyDataClassRenderer`
-This option allows you to use the old way of creating classes with parameters that has default values.
-
-From 2.10.0 reflection is used create data classes, but by setting this option to `true` the old behavior can be used
-instead which used the `copy` method.
-
-Examples:
-<details open>
-  <summary>KSP</summary>
-
-  ```kotlin
-  ksp {
-      arg("kotshi.createAnnotationsUsingConstructor", "false")
-  }
-  ```
-</details>
-
-
-<details>
-  <summary>KAPT</summary>
-
-  ```kotlin
-  kapt {
-      arguments {
-          arg("kotshi.useLegacyDataClassRenderer", true)
-      }
-  }
-  ```
-</details>
-
 #### `kotshi.generatedAnnotation`
 This option tells Kotshi to add the `@Generated` annotation to all generated classes which is disabled by default.
 

diff --git a/compiler/src/main/kotlin/se/ansman/kotshi/Options.kt b/compiler/src/main/kotlin/se/ansman/kotshi/Options.kt
@@ -1,8 +1,6 @@
 package se.ansman.kotshi
 
 object Options {
-    const val createAnnotationsUsingConstructor = "kotshi.createAnnotationsUsingConstructor"
-    const val useLegacyDataClassRenderer = "kotshi.useLegacyDataClassRenderer"
     const val generatedAnnotation = "kotshi.generatedAnnotation"
 
     val possibleGeneratedAnnotations = setOf(Types.Java.generatedJDK9, Types.Java.generatedPreJDK9)

diff --git a/compiler/src/main/kotlin/se/ansman/kotshi/kapt/AdaptersProcessingStep.kt b/compiler/src/main/kotlin/se/ansman/kotshi/kapt/AdaptersProcessingStep.kt
@@ -38,8 +38,6 @@ class AdaptersProcessingStep(
     private val types: Types,
     private val elements: Elements,
     private val generatedAnnotation: GeneratedAnnotation?,
-    private val createAnnotationsUsingConstructor: Boolean?,
-    private val useLegacyDataClassRenderer: Boolean,
 ) : KotshiProcessor.GeneratingProcessingStep() {
     override val annotations: Set<Class<out Annotation>> =
         setOf(
@@ -146,8 +144,6 @@ class AdaptersProcessingStep(
                 adapters += generator.generateAdapter(
                     generatedAnnotation = generatedAnnotation,
                     filer = filer,
-                    createAnnotationsUsingConstructor = createAnnotationsUsingConstructor,
-                    useLegacyDataClassRenderer = useLegacyDataClassRenderer
                 )
             } catch (e: KaptProcessingError) {
                 messager.logKotshiError(e)

diff --git a/compiler/src/main/kotlin/se/ansman/kotshi/kapt/FactoryProcessingStep.kt b/compiler/src/main/kotlin/se/ansman/kotshi/kapt/FactoryProcessingStep.kt
@@ -51,7 +51,6 @@ class FactoryProcessingStep(
     private val generatedAnnotation: GeneratedAnnotation?,
     private val generatedAdapters: List<GeneratedAdapter<Element>>,
     private val metadataAccessor: MetadataAccessor,
-    private val createAnnotationsUsingConstructor: Boolean?,
 ) : KotshiProcessor.GeneratingProcessingStep() {
 
     @OptIn(ExperimentalKotshiApi::class)
@@ -101,9 +100,7 @@ class FactoryProcessingStep(
             manuallyRegisteredAdapters = manuallyRegisteredAdapters,
         )
 
-        val createAnnotationsUsingConstructor =
-            createAnnotationsUsingConstructor
-                ?: metadataAccessor.getMetadata(element).supportsCreatingAnnotationsWithConstructor
+        val createAnnotationsUsingConstructor = metadataAccessor.getMetadata(element).supportsCreatingAnnotationsWithConstructor
 
         JsonAdapterFactoryRenderer(factory, createAnnotationsUsingConstructor)
             .render(generatedAnnotation) {

diff --git a/compiler/src/main/kotlin/se/ansman/kotshi/kapt/KotshiProcessor.kt b/compiler/src/main/kotlin/se/ansman/kotshi/kapt/KotshiProcessor.kt
@@ -27,8 +27,6 @@ import javax.lang.model.util.Types
 @AutoService(Processor::class)
 @IncrementalAnnotationProcessor(AGGREGATING)
 class KotshiProcessor : AbstractProcessor() {
-    private var createAnnotationsUsingConstructor: Boolean? = null
-    private var useLegacyDataClassRenderer: Boolean = false
     private var generatedAnnotation: GeneratedAnnotation? = null
     private lateinit var elements: Elements
     private lateinit var types: Types
@@ -49,8 +47,6 @@ class KotshiProcessor : AbstractProcessor() {
                 types = types,
                 elements = processingEnv.elementUtils,
                 generatedAnnotation = generatedAnnotation,
-                createAnnotationsUsingConstructor = createAnnotationsUsingConstructor,
-                useLegacyDataClassRenderer = useLegacyDataClassRenderer,
             ),
             FactoryProcessingStep(
                 processor = this,
@@ -61,16 +57,13 @@ class KotshiProcessor : AbstractProcessor() {
                 generatedAnnotation = generatedAnnotation,
                 generatedAdapters = adapters,
                 metadataAccessor = metadataAccessor,
-                createAnnotationsUsingConstructor = createAnnotationsUsingConstructor,
             )
         )
     }
 
     @Synchronized
     override fun init(processingEnv: ProcessingEnvironment) {
         super.init(processingEnv)
-        createAnnotationsUsingConstructor = processingEnv.options[Options.createAnnotationsUsingConstructor]?.toBooleanStrict()
-        useLegacyDataClassRenderer = processingEnv.options[Options.useLegacyDataClassRenderer]?.toBooleanStrict() ?: useLegacyDataClassRenderer
         generatedAnnotation = processingEnv.options[Options.generatedAnnotation]
             ?.let { name ->
                 Options.possibleGeneratedAnnotations[name] ?: run {
@@ -95,7 +88,7 @@ class KotshiProcessor : AbstractProcessor() {
     override fun getSupportedAnnotationTypes(): Set<String> =
         getSupportedAnnotationClasses().mapTo(mutableSetOf()) { it.canonicalName }
 
-    override fun getSupportedOptions(): Set<String> = setOf("kotshi.createAnnotationsUsingConstructor")
+    override fun getSupportedOptions(): Set<String> = setOf(Options.generatedAnnotation)
 
     override fun process(annotations: Set<TypeElement>, roundEnv: RoundEnvironment): Boolean {
         if (!roundEnv.processingOver()) {

diff --git a/compiler/src/main/kotlin/se/ansman/kotshi/kapt/generators/AdapterGenerator.kt b/compiler/src/main/kotlin/se/ansman/kotshi/kapt/generators/AdapterGenerator.kt
@@ -62,8 +62,6 @@ abstract class AdapterGenerator(
     fun generateAdapter(
         generatedAnnotation: GeneratedAnnotation?,
         filer: Filer,
-        createAnnotationsUsingConstructor: Boolean?,
-        useLegacyDataClassRenderer: Boolean,
     ): GeneratedAdapter<Element> {
         when {
             kmClass.isInner ->
@@ -76,9 +74,7 @@ abstract class AdapterGenerator(
 
         val generatedAdapter = getGeneratableJsonAdapter()
             .createRenderer(
-                createAnnotationsUsingConstructor = createAnnotationsUsingConstructor
-                    ?: metadataAccessor.getMetadata(targetElement).supportsCreatingAnnotationsWithConstructor,
-                useLegacyDataClassRenderer = useLegacyDataClassRenderer,
+                createAnnotationsUsingConstructor = metadataAccessor.getMetadata(targetElement).supportsCreatingAnnotationsWithConstructor,
                 error = { KaptProcessingError(it, targetElement) },
             )
             .render(generatedAnnotation, originatingElement = targetElement) {

diff --git a/compiler/src/main/kotlin/se/ansman/kotshi/ksp/KotshiSymbolProcessor.kt b/compiler/src/main/kotlin/se/ansman/kotshi/ksp/KotshiSymbolProcessor.kt
@@ -49,13 +49,7 @@ import se.ansman.kotshi.model.findKotshiConstructor
 import se.ansman.kotshi.renderer.JsonAdapterFactoryRenderer
 
 class KotshiSymbolProcessor(private val environment: SymbolProcessorEnvironment) : SymbolProcessor {
-    private val createAnnotationsUsingConstructor = environment.options[Options.createAnnotationsUsingConstructor]
-        ?.toBooleanStrict()
-        ?: environment.kotlinVersion.isAtLeast(1, 6)
-
-    private val useLegacyDataClassRenderer = environment.options[Options.useLegacyDataClassRenderer]
-        ?.toBooleanStrict()
-        ?: false
+    private val createAnnotationsUsingConstructor = environment.kotlinVersion.isAtLeast(1, 6)
 
     private val generatedAnnotation = environment.options[Options.generatedAnnotation]
         ?.let { name ->
@@ -329,7 +323,6 @@ class KotshiSymbolProcessor(private val environment: SymbolProcessorEnvironment)
 
                 generator.generateAdapter(
                     createAnnotationsUsingConstructor = createAnnotationsUsingConstructor,
-                    useLegacyDataClassRenderer = useLegacyDataClassRenderer,
                     generatedAnnotation = generatedAnnotation,
                 )
             } catch (e: KspProcessingError) {

diff --git a/compiler/src/main/kotlin/se/ansman/kotshi/ksp/generators/AdapterGenerator.kt b/compiler/src/main/kotlin/se/ansman/kotshi/ksp/generators/AdapterGenerator.kt
@@ -64,7 +64,6 @@ abstract class AdapterGenerator(
 
     fun generateAdapter(
         createAnnotationsUsingConstructor: Boolean,
-        useLegacyDataClassRenderer: Boolean,
         generatedAnnotation: GeneratedAnnotation?,
     ): GeneratedAdapter<KSFile> {
         when {
@@ -81,7 +80,6 @@ abstract class AdapterGenerator(
         val generatedAdapter = getGeneratableJsonAdapter()
             .createRenderer(
                 createAnnotationsUsingConstructor = createAnnotationsUsingConstructor,
-                useLegacyDataClassRenderer = useLegacyDataClassRenderer,
                 error = { KspProcessingError(it, targetElement) },
             )
             .render(generatedAnnotation, originatingElement = targetElement.containingFile!!) {

diff --git a/compiler/src/main/kotlin/se/ansman/kotshi/renderer/AdapterRenderer.kt b/compiler/src/main/kotlin/se/ansman/kotshi/renderer/AdapterRenderer.kt
@@ -145,16 +145,10 @@ abstract class AdapterRenderer(private val adapter: GeneratableJsonAdapter) {
 
 fun GeneratableJsonAdapter.createRenderer(
     createAnnotationsUsingConstructor: Boolean,
-    useLegacyDataClassRenderer: Boolean,
     error: (String) -> Throwable,
 ): AdapterRenderer =
     when (this) {
-        is DataClassJsonAdapter ->
-            if (useLegacyDataClassRenderer) {
-                LegacyDataClassAdapterRenderer(this, createAnnotationsUsingConstructor)
-            } else {
-                DataClassAdapterRenderer(this, createAnnotationsUsingConstructor)
-            }
+        is DataClassJsonAdapter -> DataClassAdapterRenderer(this, createAnnotationsUsingConstructor)
         is EnumJsonAdapter -> EnumAdapterRenderer(this)
         is ObjectJsonAdapter -> ObjectAdapterRenderer(this)
         is SealedClassJsonAdapter -> SealedClassAdapterRenderer(this, error)