Class<?> clazz;
        try {
            clazz = classLoader.loadClass(BEACON_CLASS_NAME);
        } catch (ClassNotFoundException e) {
            clazz = CurrentGradleInstallationLocator.class;
        }
        return locateViaClass(clazz);
    }

    static CurrentGradleInstallation locateViaClass(Class<?> clazz) {
        File dir = findDistDir(clazz);
        if (dir == null) {

        val clazz = readClass()
        val fields = clazz.relevantFields

        val args = readFields(fields)
        val types = fields.map { it.type }.toTypedArray()
        return try {
            clazz.getConstructor(*types).newInstance(*args.toTypedArray())
        } catch (ex: Exception) {
            throw IllegalStateException("Failed to create instance of ${clazz.name} with args $args", ex)
        }

            this.type = type;
        }

        public RelevantMethods build() {
            for (Class<?> clazz = type; clazz != Object.class && clazz != DefaultServiceRegistry.class; clazz = clazz.getSuperclass()) {
                for (Method method : clazz.getDeclaredMethods()) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        continue;
                    }

                .distinct()
                .forEach(key -> {
                    Class<?> clazz = key.getRawType();
                    Class<Object> itf = (clazz.isInterface()
                            ? null
                            : (Class<Object>) (clazz.getInterfaces().length > 0 ? clazz.getInterfaces()[0] : clazz));
                    if (itf != null) {

            throw new IllegalStateException();
        }
        values.remove(0);
    }

    public <T> void seed(Class<T> clazz, Provider<T> value) {
        getScopeState().seed(clazz, value);
    }

    public <T> void seed(Class<T> clazz, final T value) {
        seed(clazz, (Provider<T>) () -> value);
    }

    public <T> Provider<T> scope(final Key<T> key, final Provider<T> unscoped) {

        if (stack.isEmpty()) {
            values.remove();
        }
    }

    public <T> void seed(Class<T> clazz, Provider<T> value) {
        getScopeState().seeded.put(Key.get(clazz), value);
    }

    public <T> void seed(Class<T> clazz, final T value) {
        getScopeState().seeded.put(Key.get(clazz), Providers.of(value));
    }

    public <T> Provider<T> scope(final Key<T> key, final Provider<T> unscoped) {

        given:
        def jar = distDir.file("$jarDirectory/mydep-1.2.jar")
        createJarFile(jar)

        when:
        def clazz = loadClassFromJar(jar)
        def installation = CurrentGradleInstallationLocator.locateViaClass(clazz).getInstallation()

        then:
        installation.gradleHome == distDir
        installation.libDirs == [new File(distDir, 'lib'), new File(distDir, 'lib/plugins')]

        val cleared = readBoolean()
        val updates = readList {
            val clazz = readClass()
            val key = read() as Any
            val value = read()
            when (clazz) {
                ConfigurationCacheEnvironmentChangeTracker.SystemPropertyMutate::class.java ->

}

public class UnsupportedSymbolKind(identifier: String, kind: KaSymbolKind) : IllegalStateException(
    "For symbol with kind = KaSymbolKind.${kind.name} was $identifier"
) {
    public constructor(clazz: KClass<*>, kind: KaSymbolKind) : this(clazz.java.simpleName, kind)

                    try {
                        def clazz = systemLoader.loadClass(nonLauncherOrCoreClass)
                        assert clazz == null : "ClassNotFoundException should have been thrown trying to load a “\${nonLauncherOrCoreClass}” class from the system classloader as its not a launcher or core class (loaded class: \$clazz)"
                    } catch (ClassNotFoundException e) {
                        // expected