localSourcePath: ClassPath
): IntermediateScriptModel? {

    val buildScript = project.discoverBuildScript()
        ?: return null

    // TODO:isolated this relies on the hierarchy of classloaders
    val compilationClassPath = project.scriptCompilationClassPath

    val accessorsClassPath = project.serviceOf<ClassPathModeExceptionCollector>().runCatching {
        project.accessorsClassPathOf(compilationClassPath)

        // NOTE: We do not want/need a decorated version of JavaForkOptions or JavaDebugOptions because
        // these immutable instances are held across builds and will retain classloaders/services in the decorated object

            action += """
                URL[] urls = parameters.files.collect { new File(getParameters().getOutputDir(), it).toURI().toURL() }
                ClassLoader classloader = new URLClassLoader(urls)
                Thread.currentThread().setContextClassLoader(classloader)
            """
        }
        workerThatChangesContextClassLoader.writeToBuildFile()

            The problem there is that Gradle then tries to load the native library in two different classloaders in the same JDK, which isn't allowed.
            We could try to fix this problems, though this is only a problem for testing.
        """
    )
    @TargetGradleVersion(">=3.0")

[NOTE]
====
GradleRunner supports the same range of Gradle versions as the Tooling API.

    }
    return builder.build();
  }

  @VisibleForTesting
  static ImmutableMap<File, ClassLoader> getClassPathEntries(ClassLoader classloader) {
    LinkedHashMap<File, ClassLoader> entries = Maps.newLinkedHashMap();
    // Search parent first, since it's the order ClassLoader#loadClass() uses.
    ClassLoader parent = classloader.getParent();
    if (parent != null) {
      entries.putAll(getClassPathEntries(parent));
    }

    }
    return builder.build();
  }

  @VisibleForTesting
  static ImmutableMap<File, ClassLoader> getClassPathEntries(ClassLoader classloader) {
    LinkedHashMap<File, ClassLoader> entries = Maps.newLinkedHashMap();
    // Search parent first, since it's the order ClassLoader#loadClass() uses.
    ClassLoader parent = classloader.getParent();
    if (parent != null) {
      entries.putAll(getClassPathEntries(parent));
    }

import org.gradle.api.internal.initialization.loadercache.ClassLoaderId;

import java.util.Arrays;

/**
 * Provides implementations of classloader ids
 */
public class ClassLoaderIds {

    public enum Type {
        SCRIPT,
        TEST_TASK_CLASSPATH
    }

    private static ClassLoaderId of(Type type, String... attributes) {
        return new DefaultClassLoaderId(type, attributes);

 */

package org.gradle.api.internal.initialization.loadercache;

import org.gradle.api.Describable;

/**
 * Opaque identifier of the classloader. Needed for correct behavior of classloader invalidation.
 */
public interface ClassLoaderId extends Describable {
    @Override
    boolean equals(Object o);
    @Override
    int hashCode();

        }
        ClassLoader classLoader = classLoaderCache.get(classLoaderId, classPath, parent, null);
        listener.classloaderCreated(this.id, classLoaderId, classLoader, classPath, null);
        if (ownLoaders == null) {
            ownLoaders = new ArrayList<>();
        }
        ownLoaders.add(classLoader);
        return classLoader;
    }

    @Override