}

    @Override
    public boolean defines(Class<?> clazz) {
        return localClassLoader.equals(clazz.getClassLoader());
    }

    @Override
    public void onReuse() {
        parent.onReuse();
        listener.childScopeCreated(parent.getId(), id, origin);
        listener.classloaderCreated(id, id.localId(), localClassLoader, classPath, classpathImplementationHash);
    }

    @Override

) {

    private
    val cache: CrossBuildInMemoryCache<ProgramId, CompiledScript> = cacheFactory.newCache()

    fun get(key: ProgramId): CompiledScript? =
        cache.getIfPresent(key)?.also { it.onReuse() }

    fun put(key: ProgramId, loadedScriptClass: CompiledScript) {
        cache.put(key, loadedScriptClass)
    }

 */

package org.gradle.kotlin.dsl.execution

import org.gradle.internal.classpath.ClassPath


internal
interface CompiledScript {
    val program: Class<*>
    val classPath: ClassPath

    fun onReuse()

     */
    boolean getHasMethods();

    Class<? extends T> loadClass();

    D getData();

    /**
     * Called when this script is reused in a new build invocation.
     */
    void onReuse();

    }

    @Override
    public ClassLoaderScope lock() {
        return this;
    }

    @Override
    public boolean isLocked() {
        return true;
    }

    @Override
    public void onReuse() {
        // Nothing to do
    }

        locked = true;
        return this;
    }

    @Override
    public boolean isLocked() {
        return locked;
    }

    @Override
    public void onReuse() {
        parent.onReuse();
        listener.childScopeCreated(parent.getId(), id, origin);
        if (!export.isEmpty()) {
            listener.classloaderCreated(this.id, id.exportId(), effectiveExportClassLoader, export, null);

        HashCode hash = source.getResource().getContentHash();
        if (cached != null) {
            if (hash.equals(cached.hash)) {
                cached.compiledScript.onReuse();
                return Cast.uncheckedCast(cached.compiledScript);
            }
        }
        CompiledScript<T, M> compiledScript = delegate.compile(source, scriptBaseClass, target, targetScope, operation, verifier);

                }
                return loadedClass!!
            }

        @Synchronized
        override fun onReuse() {
            scope?.let {
                // Recreate the script scope and ClassLoader, so that things that use scopes are notified that the scope exists
                it.onReuse()
                require(loadedClass!!.classLoader == it.localClassLoader)
            }
        }

        private

     * been discarded to reduce memory pressure.
     */
    void onReuse();

    ClassLoaderScope getOriginalScope();

    }
}


class DummyCompiledScript(override val program: Class<*>) : CompiledScript {

    override val classPath: ClassPath
        get() = ClassPath.EMPTY

    override fun onReuse() {
    }

    override fun equals(other: Any?) = when {
        other === this -> true
        other == null || other.javaClass != this.javaClass -> false