Runtime.value = "after"
        assertThat(
            extract(value),
            equalTo("before")
        )
    }

    object Runtime {
        private
        val local = ThreadLocal<Any?>()

        var value: Any?
            get() = local.get()
            set(value) = local.set(value)
    }

    data class BeanOf<T>(val value: T)

 * [analyze][org.jetbrains.kotlin.analysis.api.analyze] call.
 */
internal class KaBaseWriteActionStartedChecker(parentDisposable: Disposable) {
    private val currentAnalyzeCallDepth = ThreadLocal.withInitial { 0 }

    init {
        val listener = object : ApplicationListener {
            override fun writeActionFinished(action: Any) {
                if (currentAnalyzeCallDepth.get() > 0) {

    private final Clock clock;
    private final BuildOperationIdFactory buildOperationIdFactory;
    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<ProgressLoggerImpl> current = new ThreadLocal<ProgressLoggerImpl>();
    private final CurrentBuildOperationRef currentBuildOperationRef = CurrentBuildOperationRef.instance();

import org.jetbrains.kotlin.analysis.api.platform.lifetime.KaLifetimeTracker

internal class KaBaseLifetimeTracker : KaLifetimeTracker {
    private val lifetimeOwnersStack = ThreadLocal.withInitial<PersistentList<KtLifetimeToken>> { persistentListOf() }

    override val currentToken: KtLifetimeToken? get() = lifetimeOwnersStack.get().lastOrNull()

    fun beforeEnteringAnalysis(session: KtAnalysisSession) {

      }
    }
  }

  /**
   * ThreadLocal holding a single-slot int array holding hash code. Unlike the JDK8 version of this
   * class, we use a suboptimal int[] representation to avoid introducing a new type that can impede
   * class-unloading when ThreadLocals are not removed.
   */
  static final ThreadLocal<int @Nullable []> threadHashCode = new ThreadLocal<>();

  /** Generator of new random hash codes */

      }
    }
  }

  /**
   * ThreadLocal holding a single-slot int array holding hash code. Unlike the JDK8 version of this
   * class, we use a suboptimal int[] representation to avoid introducing a new type that can impede
   * class-unloading when ThreadLocals are not removed.
   */
  static final ThreadLocal<int @Nullable []> threadHashCode = new ThreadLocal<>();

  /** Generator of new random hash codes */

      }
    }
  }

  /**
   * ThreadLocal holding a single-slot int array holding hash code. Unlike the JDK8 version of this
   * class, we use a suboptimal int[] representation to avoid introducing a new type that can impede
   * class-unloading when ThreadLocals are not removed.
   */
  static final ThreadLocal<int @Nullable []> threadHashCode = new ThreadLocal<>();

  /** Generator of new random hash codes */

      }
    }
  }

  /**
   * ThreadLocal holding a single-slot int array holding hash code. Unlike the JDK8 version of this
   * class, we use a suboptimal int[] representation to avoid introducing a new type that can impede
   * class-unloading when ThreadLocals are not removed.
   */
  static final ThreadLocal<int @Nullable []> threadHashCode = new ThreadLocal<>();

  /** Generator of new random hash codes */

        val problemsReportedInCurrentCall: MutableSet<Any> = HashSet(1)
    }

    private
    class State {
        val callStack = Stack<CallEntry>()
    }

    private
    val threadLocalState = ThreadLocal.withInitial { State() }

    override fun enterDynamicCall(entryPoint: Any) {
        currentThreadState.callStack.push(CallEntry(entryPoint))
    }

    override fun leaveDynamicCall(entryPoint: Any) {

            }
        }
    }

    static abstract class StatusTrackingValueSource implements ValueSource<Boolean, ValueSourceParameters.None> {
        static final ThreadLocal<Boolean> INSIDE_COMPUTATION = ThreadLocal.withInitial(() -> false)

        private boolean isInsideComputationInConstructor

        StatusTrackingValueSource() {
            isInsideComputationInConstructor = INSIDE_COMPUTATION.get()