Add lock parameter

Author: mori-atsushi

cacheable-compiler/src/main/kotlin/com/moriatsushi/cacheable/compiler/declaration/CacheStoreClassDeclaration.kt

@@ -32,27 +32,30 @@ class CacheStoreClassDeclaration(
 
     private val irConstructorSymbol: IrConstructorSymbol
         get() = irClassSymbol.constructors.single {
-            it.owner.valueParameters.size == 1 &&
-                it.owner.valueParameters.first().type == irBuiltIns.intType
+            it.owner.valueParameters.size == 2 &&
+                it.owner.valueParameters[0].type == irBuiltIns.intType &&
+                it.owner.valueParameters[1].type == irBuiltIns.booleanType
         }
 
     private val irCacheOrInvokeFunctionSymbol: IrSimpleFunctionSymbol
         get() = irClassSymbol.functions
             .single { it.owner.name == cacheOrInvokedFunctionName }
 
-    fun createConstructorCall(maxCountExpression: IrExpression?): IrConstructorCall {
+    fun createConstructorCall(
+        maxCountExpression: IrExpression?,
+        lockExpression: IrExpression?,
+    ): IrConstructorCall {
         val call = IrConstructorCallImpl(
             startOffset = UNDEFINED_OFFSET,
             endOffset = UNDEFINED_OFFSET,
             type = irType,
             symbol = irConstructorSymbol,
             typeArgumentsCount = 0,
             constructorTypeArgumentsCount = 0,
-            valueArgumentsCount = 1,
+            valueArgumentsCount = 2,
         )
-        if (maxCountExpression != null) {
-            call.putValueArgument(0, maxCountExpression)
-        }
+        call.putValueArgument(0, maxCountExpression)
+        call.putValueArgument(1, lockExpression)
         return call
     }
 

cacheable-compiler/src/main/kotlin/com/moriatsushi/cacheable/compiler/declaration/CacheableAnnotationDeclaration.kt

@@ -14,7 +14,12 @@ class CacheableAnnotationDeclaration {
     fun findMaxCountExpression(annotationContainer: IrAnnotationContainer): IrExpression? =
         annotationContainer.getAnnotation(name)
             ?.valueArguments
-            ?.firstOrNull()
+            ?.getOrNull(0)
+
+    fun findLockExpression(annotationContainer: IrAnnotationContainer): IrExpression? =
+        annotationContainer.getAnnotation(name)
+            ?.valueArguments
+            ?.getOrNull(1)
 
     companion object {
         val name = FqName("com.moriatsushi.cacheable.Cacheable")

cacheable-compiler/src/main/kotlin/com/moriatsushi/cacheable/compiler/declaration/CacheableDeclarations.kt

@@ -5,19 +5,19 @@ import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
 class CacheableDeclarations(
     val cacheableAnnotationDeclaration: CacheableAnnotationDeclaration,
     val cacheStoreClassDeclaration: CacheStoreClassDeclaration,
-    val suspendCacheStoreClassDeclaration: SuspendCacheStoreClassDeclaration,
+    val coroutineCacheStoreClassDeclaration: CoroutineCacheStoreClassDeclaration,
 ) {
     companion object {
         fun find(pluginContext: IrPluginContext): CacheableDeclarations? {
             val cacheStoreClassDeclaration =
                 CacheStoreClassDeclaration.find(pluginContext) ?: return null
-            val suspendCacheStoreClassDeclaration =
-                SuspendCacheStoreClassDeclaration.find(pluginContext) ?: return null
+            val coroutineCacheStoreClassDeclaration =
+                CoroutineCacheStoreClassDeclaration.find(pluginContext) ?: return null
 
             return CacheableDeclarations(
                 CacheableAnnotationDeclaration(),
                 cacheStoreClassDeclaration,
-                suspendCacheStoreClassDeclaration,
+                coroutineCacheStoreClassDeclaration,
             )
         }
     }

cacheable-compiler/src/main/kotlin/com/moriatsushi/cacheable/compiler/declaration/SuspendCacheStoreClassDeclaration.kt renamed to cacheable-compiler/src/main/kotlin/com/moriatsushi/cacheable/compiler/declaration/CoroutineCacheStoreClassDeclaration.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
-class SuspendCacheStoreClassDeclaration(
+class CoroutineCacheStoreClassDeclaration(
     private val irClassSymbol: IrClassSymbol,
     private val irBuiltIns: IrBuiltIns,
 ) {
@@ -32,27 +32,30 @@ class SuspendCacheStoreClassDeclaration(
 
     private val irConstructorSymbol: IrConstructorSymbol
         get() = irClassSymbol.constructors.single {
-            it.owner.valueParameters.size == 1 &&
-                it.owner.valueParameters.first().type == irBuiltIns.intType
+            it.owner.valueParameters.size == 2 &&
+                it.owner.valueParameters[0].type == irBuiltIns.intType &&
+                it.owner.valueParameters[1].type == irBuiltIns.booleanType
         }
 
     private val irCacheOrInvokeFunctionSymbol: IrSimpleFunctionSymbol
         get() = irClassSymbol.functions
             .single { it.owner.name == cacheOrInvokedFunctionName }
 
-    fun createConstructorCall(maxCountExpression: IrExpression?): IrConstructorCall {
+    fun createConstructorCall(
+        maxCountExpression: IrExpression?,
+        lockExpression: IrExpression?,
+    ): IrConstructorCall {
         val call = IrConstructorCallImpl(
             startOffset = UNDEFINED_OFFSET,
             endOffset = UNDEFINED_OFFSET,
             type = irType,
             symbol = irConstructorSymbol,
             typeArgumentsCount = 0,
             constructorTypeArgumentsCount = 0,
-            valueArgumentsCount = 1,
+            valueArgumentsCount = 2,
         )
-        if (maxCountExpression != null) {
-            call.putValueArgument(0, maxCountExpression)
-        }
+        call.putValueArgument(0, maxCountExpression)
+        call.putValueArgument(1, lockExpression)
         return call
     }
 
@@ -90,9 +93,9 @@ class SuspendCacheStoreClassDeclaration(
             ClassId(internalPackageName, Name.identifier("CoroutineCacheStore"))
         private val cacheOrInvokedFunctionName = Name.identifier("cacheOrInvoke")
 
-        fun find(pluginContext: IrPluginContext): SuspendCacheStoreClassDeclaration? =
+        fun find(pluginContext: IrPluginContext): CoroutineCacheStoreClassDeclaration? =
             pluginContext.referenceClass(cacheStoreId)?.let {
-                SuspendCacheStoreClassDeclaration(it, pluginContext.irBuiltIns)
+                CoroutineCacheStoreClassDeclaration(it, pluginContext.irBuiltIns)
             }
     }
 }

cacheable-compiler/src/main/kotlin/com/moriatsushi/cacheable/compiler/factory/IrCacheStoreFieldFactory.kt

@@ -19,7 +19,7 @@ class IrCacheStoreFieldFactory(
         val field = irFactory.buildField {
             name = Name.identifier(function.name.identifier + CACHE_STORE_SUFFIX)
             type = if (function.isSuspend) {
-                cacheableDeclarations.suspendCacheStoreClassDeclaration.irType
+                cacheableDeclarations.coroutineCacheStoreClassDeclaration.irType
             } else {
                 cacheableDeclarations.cacheStoreClassDeclaration.irType
             }
@@ -28,12 +28,14 @@ class IrCacheStoreFieldFactory(
         }
         val maxCountExpression = cacheableDeclarations.cacheableAnnotationDeclaration
             .findMaxCountExpression(function)
+        val lockExpression = cacheableDeclarations.cacheableAnnotationDeclaration
+            .findLockExpression(function)
         val constructorCall = if (function.isSuspend) {
-            cacheableDeclarations.suspendCacheStoreClassDeclaration
-                .createConstructorCall(maxCountExpression)
+            cacheableDeclarations.coroutineCacheStoreClassDeclaration
+                .createConstructorCall(maxCountExpression, lockExpression)
         } else {
             cacheableDeclarations.cacheStoreClassDeclaration
-                .createConstructorCall(maxCountExpression)
+                .createConstructorCall(maxCountExpression, lockExpression)
         }
         field.initializer = irFactory.createExpressionBody(constructorCall)
         field.parent = function.parent

cacheable-compiler/src/main/kotlin/com/moriatsushi/cacheable/compiler/factory/IrCacheableFunctionBodyFactory.kt

@@ -154,7 +154,7 @@ class IrCacheableFunctionBodyFactory(
             )
         }
         return if (isSuspend) {
-            cacheableDeclarations.suspendCacheStoreClassDeclaration
+            cacheableDeclarations.coroutineCacheStoreClassDeclaration
                 .createCacheOrInvokeFunctionCall(
                     typeArgument = typeArgument,
                     keyElements = keyElements,

cacheable-core/src/commonMain/kotlin/com/moriatsushi/cacheable/Cacheable.kt

@@ -8,11 +8,18 @@ package com.moriatsushi.cacheable
  *
  * @param maxCount The maximum number of caches. If the number of caches exceeds this value, the
  * last used cache will be deleted. The default value is [unlimited][UNLIMITED_CACHE_COUNT].
+ * @param lock When this is true, the function is guaranteed to be called only once even if the
+ * function is called multiple times with the same arguments at the same time. Otherwise, the
+ * function may be called multiple times with the same arguments at the same time. The default value
+ * is false.
  */
 @Target(AnnotationTarget.FUNCTION)
 @Retention(AnnotationRetention.SOURCE)
 @MustBeDocumented
-annotation class Cacheable(val maxCount: Int = UNLIMITED_CACHE_COUNT)
+annotation class Cacheable(
+    val maxCount: Int = UNLIMITED_CACHE_COUNT,
+    val lock: Boolean = false,
+)
 
 /**
  * A constant indicating that the number of caches is unlimited.

cacheable-core/src/commonMain/kotlin/com/moriatsushi/cacheable/internal/CacheStore.kt

@@ -12,7 +12,10 @@ internal class CacheStore(
     private val lockStore: LockStore<SynchronizedObject> = LockStore.SynchronizedObjectStore,
     private val lock: Boolean = false,
 ) {
-    constructor(maxCount: Int = UNLIMITED_CACHE_COUNT) : this(BaseCacheStore(maxCount))
+    constructor(
+        maxCount: Int = UNLIMITED_CACHE_COUNT,
+        lock: Boolean = false,
+    ) : this(BaseCacheStore(maxCount), lock = lock)
 
     inline fun <T> cacheOrInvoke(vararg key: Any?, value: () -> T): T {
         val keyList = key.toList()

cacheable-core/src/commonMain/kotlin/com/moriatsushi/cacheable/internal/CoroutineCacheStore.kt

@@ -12,7 +12,10 @@ internal class CoroutineCacheStore(
     private val lockStore: LockStore<Mutex> = LockStore.MutexStore,
     private val lock: Boolean = false,
 ) {
-    constructor(maxCount: Int = UNLIMITED_CACHE_COUNT) : this(BaseCacheStore(maxCount))
+    constructor(
+        maxCount: Int = UNLIMITED_CACHE_COUNT,
+        lock: Boolean = false,
+    ) : this(BaseCacheStore(maxCount), lock = lock)
 
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
     suspend inline fun <T> cacheOrInvoke(vararg key: Any?, value: suspend () -> T): T {