}

        private
        fun createSettings(): SettingsState {
            val baseClassLoaderScope = gradle.classLoaderScope
            val classLoaderScope = baseClassLoaderScope.createChild("settings", null)
            val settingsSource = TextResourceScriptSource(service<TextFileResourceLoader>().loadFile("settings file", settingsFile))

            throw e.cause as? ScriptCompilationException ?: e
        }

        override fun compilationClassPathOf(classLoaderScope: ClassLoaderScope): ClassPath =
            classPathProvider.compilationClassPathOf(classLoaderScope)

        override fun loadClassInChildScopeOf(
            classLoaderScope: ClassLoaderScope,
            childScopeId: String,
            origin: ClassLoaderScopeOrigin,
            location: File,

    public void setClassLoaderScope(Supplier<? extends ClassLoaderScope> classLoaderScope) {
        if (this.classLoaderScope != null) {
            throw new IllegalStateException("Class loader scope already used");
        }
        this.classLoaderScope = classLoaderScope;
    }

    @Override
    public ClassLoaderScope getClassLoaderScope() {
        if (classLoaderScope == null) {

    /**
     * The parent scope for this and all settings objects.
     *
     * Gradle runtime.
     */
    ClassLoaderScope getBaseClassLoaderScope();

    /**
     * The scope for this settings object.
     *
     * Gradle runtime + this object's script's additions.
     */
    ClassLoaderScope getClassLoaderScope();

    ServiceRegistry getServices();

    @Override

        classes.putInstance(id, newType)
        return newType
    }

    private
    fun ReadContext.readScope(): ClassLoaderScope {
        val id = readSmallInt()
        val scope = scopes.getInstance(id)
        if (scope != null) {
            return scope as ClassLoaderScope
        }

        val parent = if (readBoolean()) {
            readScope()
        } else {

                    .get()
            }


    private
    fun configuredProjectSchemaOf(scriptTarget: Any, classLoaderScope: ClassLoaderScope): TypedProjectSchema? {
        require(classLoaderScope.isLocked) {
            "project.classLoaderScope must be locked before querying the project schema"
        }
        return projectSchemaProvider.schemaFor(scriptTarget)?.takeIf { it.isNotEmpty() }
    }

    override fun getServices(): ServiceRegistry =
        delegate.services

    override fun setClassLoaderScope(classLoaderScope: Supplier<out ClassLoaderScope>) {
        delegate.setClassLoaderScope(classLoaderScope)
    }

    override fun getClassLoaderScope(): ClassLoaderScope =
        delegate.classLoaderScope

    override fun setIncludedBuilds(includedBuilds: MutableCollection<out IncludedBuildInternal>) {

        rootState.createMutableModel(Stub(ClassLoaderScope), Stub(ClassLoaderScope))

        def project = project("p1")
        def state = registry.stateFor(projectId("p1"))

        1 * projectFactory.createProject(_, _, state, _, _, _, _) >> project

        state.createMutableModel(Stub(ClassLoaderScope), Stub(ClassLoaderScope))

        expect:
        rootState.mutableModel == rootProject

        this.scriptSourceListener = scriptSourceListener;
    }

    @Override
    public ScriptPlugin create(
        ScriptSource scriptSource, ScriptHandler scriptHandler, ClassLoaderScope targetScope,
        ClassLoaderScope baseScope, boolean topLevelScript
    ) {
        scriptSourceListener.scriptSourceObserved(scriptSource);
        ScriptPlugin scriptPlugin = scriptPluginFactoryFor(scriptSource.getFileName())

    private final ScriptClassPathResolver scriptClassPathResolver;
    private final ClassLoaderScope parentScope;
    private final PluginInspector pluginInspector;
    private final Lazy<PluginRegistry> pluginRegistry;

    public DefaultInjectedClasspathPluginResolver(
        ClassLoaderScope parentScope,
        ScriptClassPathResolver scriptClassPathResolver,
        FileCollectionFactory fileCollectionFactory,