platform.concurrency: IJPL-797 Mark accidentally public platform APIs private

GitOrigin-RevId: b4cb46d3c948e886c94fa29976b7e7c1dca25275

platform/util/concurrency/api-dump-unreviewed.txt

@@ -183,9 +183,6 @@ com.intellij.util.containers.ConcurrentThreeStateBitSet
 f:com.intellij.util.containers.ConcurrentThreeStateBitSet$Companion
 - f:create():com.intellij.util.containers.ConcurrentThreeStateBitSet
 - f:create(I):com.intellij.util.containers.ConcurrentThreeStateBitSet
-*f:org.jetbrains.concurrency.AsyncCache
-- <init>(java.util.function.Function,java.util.function.Function):V
-- f:computeOrGet(com.intellij.openapi.util.UserDataHolder):org.jetbrains.concurrency.AsyncPromise
 c:org.jetbrains.concurrency.AsyncPromise
 - org.jetbrains.concurrency.CancellablePromise
 - org.jetbrains.concurrency.Promise
@@ -233,17 +230,6 @@ a:org.jetbrains.concurrency.ObsolescentConsumer
 org.jetbrains.concurrency.ObsolescentFunction
 - com.intellij.util.Function
 - org.jetbrains.concurrency.Obsolescent
-a:org.jetbrains.concurrency.PromiseManager
-- <init>(com.intellij.util.concurrency.AtomicFieldUpdater):V
-- <init>(java.lang.Class):V
-- f:get(java.lang.Object):org.jetbrains.concurrency.Promise
-- f:get(java.lang.Object,Z):org.jetbrains.concurrency.Promise
-- f:getState(java.lang.Object):org.jetbrains.concurrency.Promise$State
-- f:has(java.lang.Object):Z
-- isUpToDate(java.lang.Object,java.lang.Object):Z
-- a:load(java.lang.Object):org.jetbrains.concurrency.Promise
-- f:reset(java.lang.Object):V
-- f:set(java.lang.Object,java.lang.Object):V
 f:org.jetbrains.concurrency.Promises
 - sf:all(java.util.Collection):org.jetbrains.concurrency.Promise
 - sf:all(java.util.Collection,java.lang.Object):org.jetbrains.concurrency.Promise

platform/util/concurrency/src/org/jetbrains/concurrency/AsyncCache.kt

@@ -1,80 +0,0 @@
-// Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
-package org.jetbrains.concurrency
-
-import com.intellij.openapi.progress.ProcessCanceledException
-import com.intellij.openapi.progress.ProgressManager
-import com.intellij.openapi.util.Key
-import com.intellij.openapi.util.ModificationTracker
-import com.intellij.openapi.util.UserDataHolder
-import org.jetbrains.annotations.ApiStatus
-import java.util.concurrent.ExecutionException
-import java.util.concurrent.atomic.AtomicReference
-import java.util.function.Function
-
-@ApiStatus.Experimental
-class AsyncCache<K : UserDataHolder,T>(
-  private val modificationTracker: Function<K, ModificationTracker>,
-  private val eval: Function<K, T>
-) {
-
-  private val key: Key<AtomicReference<Stored<T>>> = Key.create("AsyncCache${System.identityHashCode(this)}")
-
-  private data class Stored<T>(val promise: AsyncPromise<T>, val modCount: Long)
-
-  private fun isCancelled(promise: AsyncPromise<*>): Boolean {
-    if (promise.isCancelled) return true
-    if (!promise.isRejected) return false
-    try {
-      promise.get()
-    }
-    catch (e: ProcessCanceledException) {
-      return true
-    }
-    catch (e: ExecutionException) {
-      if (e.cause is ProcessCanceledException)
-        return true
-    }
-    catch (e: Exception) {
-    }
-    return false
-  }
-
-  private fun isActual(stored: Stored<T>?, modCount: Long): Boolean =
-    stored != null && stored.modCount == modCount && !isCancelled(stored.promise)
-
-  fun computeOrGet(dataHolder: K): AsyncPromise<T> {
-    val modCount = modificationTracker.apply(dataHolder).modificationCount
-    val ref = createOrGetRef(dataHolder)
-    val stored = ref.get()
-    if (isActual(stored, modCount)) return stored.promise
-
-    val newStored = Stored(AsyncPromise<T>(), modCount)
-    var curStored = stored
-    while (!ref.compareAndSet(curStored, newStored)) {
-      ProgressManager.checkCanceled()
-      curStored = ref.get()
-      if (isActual(curStored, modCount)) return curStored.promise
-    }
-
-    val promise = newStored.promise
-    try {
-      promise.setResult(eval.apply(dataHolder))
-    }
-    catch (e: Exception) {
-      promise.setError(e)
-      throw e
-    }
-    return promise
-  }
-
-  private fun createOrGetRef(dataHolder: UserDataHolder): AtomicReference<Stored<T>> {
-    dataHolder.getUserData(key)?.let { return it }
-    synchronized(key) {
-      dataHolder.getUserData(key)?.let { return it }
-      val atomicReference = AtomicReference<Stored<T>>()
-      dataHolder.putUserData(key, atomicReference)
-      return atomicReference
-    }
-  }
-
-}

platform/util/concurrency/src/org/jetbrains/concurrency/PromiseManager.java

@@ -2,12 +2,14 @@
 package org.jetbrains.concurrency;
 
 import com.intellij.util.concurrency.AtomicFieldUpdater;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeoutException;
 
+@ApiStatus.Internal
 public abstract class PromiseManager<HOST, VALUE> {
   private final AtomicFieldUpdater<HOST, Promise<VALUE>> fieldUpdater;