inputStream.defaultReadObject();
        hideCause = threadLocal();
    }

    private void writeObject(java.io.ObjectOutputStream out) throws IOException {
        // Ensure fields are initialized before serialization
        String ignored = getMessage();
        out.defaultWriteObject();
    }

    private ThreadLocal<Boolean> threadLocal() {
        return new HideStacktrace();
    }

    @Override

    private val threadLocalExplicitAnalysisRestriction: ThreadLocal<KaExplicitAnalysisRestriction?> =
        ThreadLocal.withInitial { null }

    private val threadLocalAllowOnEdt: ThreadLocal<Boolean> =
        ThreadLocal.withInitial { false }

    private val threadLocalAllowInWriteAction: ThreadLocal<Boolean> =
        ThreadLocal.withInitial { false }

 * limitations under the License.
 */

package org.gradle.cache.internal.cacheops;

public class CacheAccessOperationsStack {
    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<CacheOperationStack> stackForThread = new ThreadLocal<>();

    public void pushCacheAction() {
        CacheOperationStack stack = getOrCreateStack();
        stack.pushCacheAction();
    }

    public void popCacheAction() {

        --inputTrackingDisabledCounterForThread
    }
}


private
operator fun <T> ThreadLocal<T>.getValue(thisRef: Any?, property: KProperty<*>) = get()


private

public abstract class AbstractManagedExecutor<S extends ExecutorService> extends AbstractDelegatingExecutorService<S> implements ManagedExecutor {
    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<Object> executing = new ThreadLocal<Object>();
    private final ExecutorPolicy executorPolicy;

    public AbstractManagedExecutor(S delegate, ExecutorPolicy executorPolicy) {
        super(delegate);

public class CurrentBuildOperationRef {

    private static final CurrentBuildOperationRef INSTANCE = new CurrentBuildOperationRef();

    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<BuildOperationRef> ref = new ThreadLocal<BuildOperationRef>();

    public static CurrentBuildOperationRef instance() {
        return INSTANCE;
    }

    @Nullable
    public BuildOperationRef get() {
        return ref.get();

    private static final AtomicLong COUNTER = new AtomicLong();

    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<CurrentApplication> currentApplication = new ThreadLocal<CurrentApplication>();

    @Override
    @Nullable
    public Application current() {
        return this.currentApplication.get();
    }

    @Override

    private final BuildStartedTime buildStartedTime;
    private final Clock clock;
    @SuppressWarnings("ThreadLocalUsage")
    private final ThreadLocal<ContinuousOperation> currentTransform = new ThreadLocal<>();
    private final BuildProfile buildProfile;

    public ProfileEventAdapter(BuildProfile buildProfile, BuildStartedTime buildStartedTime, Clock clock) {

            if (!disablePsiPointer) return
            if (disablePsiPointerFlag.get()) {
                action()
            }
        }

        private val disablePsiPointerFlag: ThreadLocal<Boolean> = ThreadLocal.withInitial { false }

        @Volatile
        private var disablePsiPointer: Boolean = false
    }
}

public typealias KtPsiBasedSymbolPointer<S> = KaPsiBasedSymbolPointer<S>

        private final Map<Key<?>, Provider<?>> seeded = new HashMap<>();

        private final Map<Key<?>, Object> provided = new HashMap<>();
    }

    private final ThreadLocal<LinkedList<ScopeState>> values = new ThreadLocal<>();

    public MojoExecutionScope() {}

    public void enter() {
        LinkedList<ScopeState> stack = values.get();
        if (stack == null) {
            stack = new LinkedList<>();