Native: assume New Memory Manager

apollo-annotations/api/apollo-annotations.api

@@ -12,6 +12,7 @@ public final class com/apollographql/apollo3/annotations/ApolloDeprecatedSince$V
 	public static final field v3_3_1 Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
 	public static final field v3_3_2 Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
 	public static final field v3_3_3 Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
+	public static final field v3_4_1 Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
 	public static fun valueOf (Ljava/lang/String;)Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
 	public static fun values ()[Lcom/apollographql/apollo3/annotations/ApolloDeprecatedSince$Version;
 }

apollo-annotations/src/commonMain/kotlin/com/apollographql/apollo3/annotations/ApolloDeprecatedSince.kt

@@ -23,5 +23,6 @@ annotation class ApolloDeprecatedSince(val version: Version) {
     v3_3_1,
     v3_3_2,
     v3_3_3,
+    v3_4_1,
   }
 }

apollo-api/src/commonMain/kotlin/com/apollographql/apollo3/api/http/Http.kt

@@ -1,5 +1,7 @@
 package com.apollographql.apollo3.api.http
 
+import com.apollographql.apollo3.annotations.ApolloDeprecatedSince
+import com.apollographql.apollo3.annotations.ApolloDeprecatedSince.Version.v3_4_1
 import com.apollographql.apollo3.annotations.ApolloExperimental
 import okio.Buffer
 import okio.BufferedSink
@@ -110,8 +112,8 @@ private constructor(
      */
     private val bodySource: BufferedSource?,
     /**
-     * An immutable body that can be freezed when used from Kotlin native.
-     * Prefer [bodySource] on non-native so that the response can be streamed.
+     * An immutable body.
+     * Prefer [bodySource] on so that the response can be streamed.
      */
     private val bodyString: ByteString?,
 ) {
@@ -123,6 +125,7 @@ private constructor(
       statusCode = statusCode,
   ).apply {
     if (bodySource != null) body(bodySource)
+    @Suppress("DEPRECATION")
     if (bodyString != null) body(bodyString)
     addHeaders(headers)
   }
@@ -145,9 +148,11 @@ private constructor(
     }
 
     /**
-     * An immutable body that can be freezed when used from Kotlin native.
-     * Prefer [bodySource] on non-native so that the response can be streamed.
+     * An immutable body.
+     * Prefer [bodySource] so that the response can be streamed.
      */
+    @Deprecated("Use body(BufferedSource) instead", ReplaceWith("Buffer().write(bodyString)", "okio.Buffer"))
+    @ApolloDeprecatedSince(v3_4_1)
     fun body(bodyString: ByteString) = apply {
       check(!hasBody) { "body() can only be called once" }
       this.bodyString = bodyString

apollo-mockserver/src/appleMain/kotlin/com/apollographql/apollo3/mockserver/MockServer.kt

@@ -24,17 +24,24 @@ import platform.posix.pthread_join
 import platform.posix.pthread_tVar
 import platform.posix.sockaddr_in
 import platform.posix.socket
-import kotlin.native.concurrent.freeze
 
 /**
  * @param acceptDelayMillis: an artificial delay introduced before each `accept()`
  * call. Can be used to simulate slow connections.
  */
+@OptIn(ExperimentalStdlibApi::class)
 actual class MockServer(
     private val acceptDelayMillis: Long,
     override val mockServerHandler: MockServerHandler = QueueMockServerHandler(),
 ) : MockServerInterface {
 
+  init {
+    check(isExperimentalMM()) {
+      "Apollo: The legacy memory manager is no longer supported, please use the new memory manager instead. " +
+          "See https://github.com/JetBrains/kotlin/blob/master/kotlin-native/NEW_MM.md for more information."
+    }
+  }
+
   actual constructor(mockServerHandler: MockServerHandler) : this(0, mockServerHandler)
 
   private val pthreadT: pthread_tVar
@@ -73,7 +80,7 @@ actual class MockServer(
 
     socket = Socket(socketFd, acceptDelayMillis, mockServerHandler)
 
-    val stableRef = StableRef.create(socket!!.freeze())
+    val stableRef = StableRef.create(socket!!)
 
     pthread_create(pthreadT.ptr, null, staticCFunction { arg ->
       initRuntimeIfNeeded()

apollo-mockserver/src/appleMain/kotlin/com/apollographql/apollo3/mockserver/QueueMockServerHandler.kt

@@ -1,13 +1,12 @@
 package com.apollographql.apollo3.mockserver
 
 import platform.Foundation.NSMutableArray
-import kotlin.native.concurrent.freeze
 
 internal actual class QueueMockServerHandler : MockServerHandler {
   private val queue = NSMutableArray()
 
   actual fun enqueue(response: MockResponse) {
-    queue.addObject(response.freeze())
+    queue.addObject(response)
   }
 
   actual override fun handle(request: MockRequest): MockResponse {

apollo-mockserver/src/appleMain/kotlin/com/apollographql/apollo3/mockserver/Socket.kt

@@ -30,7 +30,6 @@ import platform.posix.usleep
 import platform.posix.write
 import kotlin.experimental.and
 import kotlin.native.concurrent.AtomicInt
-import kotlin.native.concurrent.freeze
 
 class Socket(
     private val socketFd: Int,
@@ -131,7 +130,7 @@ class Socket(
         debug("Got request: ${request.method} ${request.path}")
 
         val mockResponse = synchronized(lock) {
-          recordedRequests.addObject(request.freeze())
+          recordedRequests.addObject(request)
           try {
             mockServerHandler.handle(request)
           } catch (e: Exception) {

apollo-mpp-utils/src/appleMain/kotlin/com/apollographql/apollo3/mpp/utils.kt

@@ -5,10 +5,6 @@ import platform.Foundation.NSDateFormatter
 import platform.Foundation.NSThread
 import platform.Foundation.timeIntervalSince1970
 import platform.posix.pthread_self
-import kotlin.native.concurrent.ensureNeverFrozen
-import kotlin.native.concurrent.freeze
-import kotlin.native.concurrent.isFrozen
-import kotlin.system.getTimeMillis
 
 actual fun currentTimeMillis(): Long {
   return (NSDate().timeIntervalSince1970 * 1000).toLong()
@@ -33,19 +29,13 @@ actual fun currentThreadName(): String {
 }
 
 actual fun ensureNeverFrozen(obj: Any) {
-  obj.ensureNeverFrozen()
 }
 
-actual fun isFrozen(obj: Any) = obj.isFrozen
-
+actual fun isFrozen(obj: Any) = false
 actual fun freeze(obj: Any) {
-  obj.freeze()
 }
 
 actual fun assertMainThreadOnNative() {
-  check(NSThread.isMainThread()) {
-    "Non-main native call"
-  }
 }
 
 actual fun platform() = Platform.Native

apollo-mpp-utils/src/commonMain/kotlin/com/apollographql/apollo3/mpp/utils.kt

@@ -2,6 +2,8 @@
 
 package com.apollographql.apollo3.mpp
 
+import com.apollographql.apollo3.annotations.ApolloDeprecatedSince
+import com.apollographql.apollo3.annotations.ApolloDeprecatedSince.Version.v3_4_1
 import com.apollographql.apollo3.annotations.ApolloInternal
 import kotlin.jvm.JvmName
 
@@ -21,12 +23,20 @@ expect fun currentThreadId(): String
 @ApolloInternal
 expect fun currentThreadName(): String
 
-expect fun ensureNeverFrozen(obj: Any)
+@Deprecated("With the new Memory Manager this method is no longer needed and is a no-op", level = DeprecationLevel.ERROR)
+@ApolloDeprecatedSince(v3_4_1)
+expect fun ensureNeverFrozen(@Suppress("UNUSED_PARAMETER") obj: Any)
 
-expect fun isFrozen(obj: Any): Boolean
+@Deprecated("With the new Memory Manager this method is no longer needed and always return false", ReplaceWith("false"), level = DeprecationLevel.ERROR)
+@ApolloDeprecatedSince(v3_4_1)
+expect fun isFrozen(@Suppress("UNUSED_PARAMETER") obj: Any): Boolean
 
-expect fun freeze(obj: Any)
+@Deprecated("With the new Memory Manager this method is no longer needed and is a no-op", level = DeprecationLevel.ERROR)
+@ApolloDeprecatedSince(v3_4_1)
+expect fun freeze(@Suppress("UNUSED_PARAMETER") obj: Any)
 
+@Deprecated("With the new Memory Manager this method is no longer needed and is a no-op", level = DeprecationLevel.ERROR)
+@ApolloDeprecatedSince(v3_4_1)
 expect fun assertMainThreadOnNative()
 
 enum class Platform {

apollo-normalized-cache-incubating/build.gradle.kts

@@ -11,6 +11,9 @@ kotlin {
         api(projects.apolloRuntime)
         api(projects.apolloNormalizedCacheApiIncubating)
         api(groovy.util.Eval.x(project, "x.dep.kotlinCoroutines"))
+        implementation(groovy.util.Eval.x(project, "x.dep.atomicfu").toString()) {
+          because("Use of ReentrantLock in DefaultApolloStore for Apple (we don't use the gradle plugin rewrite)")
+        }
       }
     }
   }

apollo-normalized-cache-incubating/src/appleMain/kotlin/com/apollographql/apollo3/cache/normalized/internal/Lock.kt

@@ -0,0 +1,17 @@
+package com.apollographql.apollo3.cache.normalized.internal
+
+import kotlinx.atomicfu.locks.ReentrantLock
+import kotlinx.atomicfu.locks.reentrantLock
+import kotlinx.atomicfu.locks.withLock
+
+internal actual class Lock {
+  private val lock: ReentrantLock = reentrantLock()
+
+  actual fun <T> read(block: () -> T): T {
+    return lock.withLock(block)
+  }
+
+  actual fun <T> write(block: () -> T): T {
+    return lock.withLock(block)
+  }
+}

apollo-normalized-cache-incubating/src/commonMain/kotlin/com/apollographql/apollo3/cache/normalized/ApolloStore.kt

@@ -175,8 +175,7 @@ interface ApolloStore {
   /**
    * Direct access to the cache.
    *
-   * @param block a function that can access the cache. The function and its captured variables will
-   * be called from a background thread and freezed
+   * @param block a function that can access the cache. The function will be called from a background thread
    */
   suspend fun <R> accessCache(block: (NormalizedCache) -> R): R
 

apollo-normalized-cache-incubating/src/commonMain/kotlin/com/apollographql/apollo3/cache/normalized/internal/ApolloCacheInterceptor.kt

@@ -39,12 +39,6 @@ import kotlinx.coroutines.launch
 internal class ApolloCacheInterceptor(
     val store: ApolloStore,
 ) : ApolloInterceptor {
-  init {
-    // The store has a MutableSharedFlow that doesn't like being frozen when using coroutines
-    // But is ok to freeze when using coroutines-native-mt (see https://github.com/apollographql/apollo-android/issues/3357)
-    // ensureNeverFrozen(store)
-  }
-
   private suspend fun <D : Operation.Data> maybeAsync(request: ApolloRequest<D>, block: suspend () -> Unit) {
     if (request.writeToCacheAsynchronously) {
       val scope = request.executionContext[ConcurrencyInfo]!!.coroutineScope