.compile(this::getCompiledBinding)
                .accept(instance);
    }

    @Override
    public Injector discover(ClassLoader classLoader) {
        try {
            Enumeration<URL> enumeration = classLoader.getResources("META-INF/maven/org.apache.maven.api.di.Inject");
            while (enumeration.hasMoreElements()) {

                }
            }

            def showUrls(classloader) {
                if (classloader instanceof java.net.URLClassLoader) {
                    classloader.URLs.each { println ">>>" + it }
                }
                if (classloader.parent != null) {
                    showUrls(classloader.parent)
                }
            }
        """
    }

    public static class ClassLoadingClassDetector implements ClassDetector {
        private final URLClassLoader classLoader;

        public ClassLoadingClassDetector(Iterable<? extends File> classpath, Iterable<? extends File> modulepath) {
            ClassPath cp = DefaultClassPath.of(Iterables.concat(classpath, modulepath));
            classLoader = new URLClassLoader(cp.getAsURLArray());
        }

        @Override

    private static class ValidationProblemCollector extends EmptyFileVisitor {
        private final ClassLoader classLoader;
        private final List<Problem> taskValidationProblems;
        private final Params params;

        public ValidationProblemCollector(List<Problem> taskValidationProblems, Params params) {
            this.classLoader = Thread.currentThread().getContextClassLoader();

    else e


private
inline fun withContextClassLoader(classLoader: ClassLoader, block: () -> Unit) {
    val currentThread = Thread.currentThread()
    val previous = currentThread.contextClassLoader
    try {
        currentThread.contextClassLoader = classLoader
        block()
    } finally {
        currentThread.contextClassLoader = previous
    }
}

import groovy.lang.MetaClass;
import groovy.lang.MetaClassRegistry;
import org.apache.commons.lang.StringUtils;
import org.gradle.internal.classanalysis.AsmConstants;
import org.gradle.internal.classloader.TransformingClassLoader;
import org.gradle.internal.classloader.VisitableURLClassLoader;
import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.reflect.PropertyAccessorType;
import org.objectweb.asm.ClassReader;

                def content = required.classLoader.getResource(fileName).bytes
                builder.put(fileName, content)
            }
        }
        def transformed = transformer.transform(DefaultClassPath.of(jar), BuildLogic)
        def filtering = new FilteringClassLoader(getClass().classLoader, new FilteringClassLoader.Spec([Action.name, Instrumented.name], [], [], [], [], [], []))

        }
    }

    def "cannot register a transform from a custom classloader"() {
        createDirs("producer", "consumer")
        settingsFile << """
            include 'producer', 'consumer'
        """
        buildFile << """
            def classLoader = new GroovyClassLoader(this.class.classLoader)

throws LogConfigurationExce; public static void release(ClassLoader); public static void releaseAll(); protected static ClassLoader getContextClassLoade() throws LogConfigurationExce; private static LogFactory getCachedFactory(ClassLoader); private static void cacheFactory(ClassLoader, LogFactory); protected static LogFactory newFactory(String, ClassLoader) throws LogConfigurationExce; private static java.io.InputStream getResourceAsStream(ClassLoader, String); static void <clinit>(); } org/apache/com...

@SuppressWarnings("GroovyPointlessBoolean")
class DefaultModelSchemaExtractorTest extends Specification {
    def store = new DefaultModelSchemaStore(DefaultModelSchemaExtractor.withDefaultStrategies())
    def classLoader = new GroovyClassLoader(getClass().classLoader)
    static final List<Class<? extends Serializable>> JDK_SCALAR_TYPES = ScalarTypes.TYPES.rawClass

    static interface NotAnnotatedInterface {}

    def "unmanaged type"() {
        expect: