Remove potential memory leak from MokkeryOption

Author: lupuuss

mokkery-core-tooling/src/main/kotlin/dev/mokkery/internal/options/MokkeryOption.kt

@@ -10,17 +10,39 @@ public data class MokkeryOption<T>(
     public val allowMultipleOccurrences: Boolean,
     public val type: MokkeryOptionType<T>,
     public val defaultValue: T?,
-    public val extras: MutableMap<Any?, Any?> = mutableMapOf(),
 )
 
 @InternalMokkeryApi
-public fun interface MokkeryOptionProjection<out P> {
+public interface MokkeryOptionProjection<out P> {
 
-    public fun create(option: MokkeryOption<*>): P
+    public fun project(option: MokkeryOption<*>): P
+
+    @InternalMokkeryApi
+    public companion object {
+
+        public operator fun <T> invoke(
+            builder: (MokkeryOption<*>) -> T
+        ): MokkeryOptionProjection<T> = DefaultMokkeryOptionProjection(builder)
+
+        public fun <T> cached(
+            builder: (MokkeryOption<*>) -> T
+        ): MokkeryOptionProjection<T> = CachedMokkeryProjection(builder)
+    }
+}
+
+private class DefaultMokkeryOptionProjection<T>(
+    private val builder: (MokkeryOption<*>) -> T
+) : MokkeryOptionProjection<T> {
+    override fun project(option: MokkeryOption<*>): T = builder(option)
+}
+
+private class CachedMokkeryProjection<T>(
+    private val builder: (MokkeryOption<*>) -> T
+) : MokkeryOptionProjection<T> {
+    private val store = mutableMapOf<MokkeryOption<*>, T>()
+    override fun project(option: MokkeryOption<*>): T = store.getOrPut(option) { builder(option) }
 }
 
 @Suppress("UNCHECKED_CAST")
 @InternalMokkeryApi
-public fun <P> MokkeryOption<*>.get(projection: MokkeryOptionProjection<P>): P {
-    return extras.getOrPut(projection) { projection.create(this) } as P
-}
+public fun <P> MokkeryOption<*>.get(projection: MokkeryOptionProjection<P>): P = projection.project(this)

mokkery-gradle/src/main/kotlin/dev/mokkery/gradle/MokkeryGradlePlugin.kt

@@ -5,7 +5,6 @@ package dev.mokkery.gradle
 import dev.mokkery.MokkeryConfig
 import dev.mokkery.MokkeryConfig.RUNTIME_DEPENDENCY
 import dev.mokkery.MokkeryConfig.VERSION
-import dev.mokkery.internal.options.MokkeryOption
 import dev.mokkery.internal.options.MokkeryOptionProjection
 import dev.mokkery.internal.options.MokkeryOptions
 import dev.mokkery.internal.options.get
@@ -34,9 +33,9 @@ public class MokkeryGradlePlugin : KotlinCompilerPluginSupportPlugin {
             .extensions
             .create("mokkery", MokkeryGradleExtension::class.java)
         mokkery.rule.convention(ApplicationRule.AllTests)
-        val projection = GradlePropertyProjection(target)
+        val gradleProperty = gradlePropertyProjection(target)
         MokkeryOptions.forEach {
-            it.get(projection)?.convention(it.defaultValue)
+            it.get(gradleProperty)?.convention(it.defaultValue)
         }
         target.configureDependencies()
         super.apply(target)
@@ -46,9 +45,9 @@ public class MokkeryGradlePlugin : KotlinCompilerPluginSupportPlugin {
         kotlinCompilation: KotlinCompilation<*>
     ): Provider<List<SubpluginOption>> = kotlinCompilation.run {
         target.project.provider {
-            val property = GradlePropertyProjection(project)
+            val gradleProperty = gradlePropertyProjection(project)
             MokkeryOptions.mapNotNull {
-                val value = it.get(property)?.get() ?: return@mapNotNull null
+                val value = it.get(gradleProperty)?.get() ?: return@mapNotNull null
                 SubpluginOption(it.name, it.type.serializer.serialize(value))
             }
         }
@@ -131,24 +130,24 @@ public class MokkeryGradlePlugin : KotlinCompilerPluginSupportPlugin {
     private fun KotlinVersion(string: String): KotlinVersion = KotlinToolingVersion(string).toKotlinVersion()
 }
 
-private data class GradlePropertyProjection(
-    val project: Project
+@Suppress("UNCHECKED_CAST")
+private fun gradlePropertyProjection(
+    project: Project
 ) : MokkeryOptionProjection<Property<Any>?> {
-
-    private val extension get() = project.mokkery
-
-    @Suppress("UNCHECKED_CAST")
-    override fun create(option: MokkeryOption<*>): Property<Any>? = when (option) {
-        MokkeryOptions.Core.defaultMockMode -> extension.defaultMockMode
-        MokkeryOptions.Core.defaultVerifyMode -> extension.defaultVerifyMode
-        MokkeryOptions.Core.ignoreFinalMembers -> extension.ignoreFinalMembers
-        MokkeryOptions.Core.ignoreInlineMembers -> extension.ignoreInlineMembers
-        MokkeryOptions.Core.enableFirDiagnostics -> extension.enableFirDiagnostics
-        MokkeryOptions.Stubs.allowClassInheritance -> extension.stubs.allowClassInheritance
-        MokkeryOptions.Stubs.allowConcreteClassInstantiation -> extension.stubs.allowConcreteClassInstantiation
-        MokkeryOptions.Annotations.copyToMock -> extension.annotations.copyToMock
-        else -> null
-    } as? Property<Any>
+    val extension = project.mokkery
+    return MokkeryOptionProjection {
+        when (it) {
+            MokkeryOptions.Core.defaultMockMode -> extension.defaultMockMode
+            MokkeryOptions.Core.defaultVerifyMode -> extension.defaultVerifyMode
+            MokkeryOptions.Core.ignoreFinalMembers -> extension.ignoreFinalMembers
+            MokkeryOptions.Core.ignoreInlineMembers -> extension.ignoreInlineMembers
+            MokkeryOptions.Core.enableFirDiagnostics -> extension.enableFirDiagnostics
+            MokkeryOptions.Stubs.allowClassInheritance -> extension.stubs.allowClassInheritance
+            MokkeryOptions.Stubs.allowConcreteClassInstantiation -> extension.stubs.allowConcreteClassInstantiation
+            MokkeryOptions.Annotations.copyToMock -> extension.annotations.copyToMock
+            else -> null
+        } as? Property<Any>
+    }
 }
 
 private val Project.mokkery get() = extensions.getByType(MokkeryGradleExtension::class.java)

mokkery-plugin/src/main/kotlin/dev/mokkery/plugin/MokkeryOption.kt

@@ -13,7 +13,7 @@ val MokkeryOption<*>.cliOption: CliOption
 val <T> MokkeryOption<T>.configurationKey: CompilerConfigurationKey<List<T>>
     get() = get(ConfigurationKeyProjection) as CompilerConfigurationKey<List<T>>
 
-private val CliOptionProjection = MokkeryOptionProjection {
+private val CliOptionProjection = MokkeryOptionProjection.cached {
     CliOption(
         optionName = it.name,
         valueDescription = it.type.description,
@@ -23,6 +23,6 @@ private val CliOptionProjection = MokkeryOptionProjection {
     )
 }
 
-private val ConfigurationKeyProjection = MokkeryOptionProjection<CompilerConfigurationKey<List<Any?>>> {
+private val ConfigurationKeyProjection = MokkeryOptionProjection.cached<CompilerConfigurationKey<List<Any?>>> {
     CompilerConfigurationKey.create(it.name)
 }