scriptTarget.getOrCreateProperty("gradleKotlinDsl.accessorsClassPath") {
            buildAccessorsClassPathFor(scriptTarget, classPath)
                ?: AccessorsClassPath.empty
        }


    private
    fun buildAccessorsClassPathFor(scriptTarget: Any, classPath: ClassPath): AccessorsClassPath? =
        classLoaderScopeOf(scriptTarget)

    val accessorsClassPath = rootProject.serviceOf<ClassPathModeExceptionCollector>().runCatching {
        settings.accessorsClassPathOf(scriptCompilationClassPath)
    } ?: AccessorsClassPath.empty

    return NonProjectScriptModel(
        settingsScript,
        scriptCompilationClassPath + accessorsClassPath.bin,

private
data class KotlinScriptTargetModelBuilder(
    val scriptFile: File?,
    val project: Project,
    val scriptClassPath: ClassPath,
    val accessorsClassPath: (ClassPath) -> AccessorsClassPath = { AccessorsClassPath.empty },
    val sourceLookupScriptHandlers: List<ScriptHandler> = emptyList(),
    val enclosingScriptProjectDir: File? = null,
    val additionalImports: () -> List<String> = { emptyList() }

                )
                executionEngine.createRequest(work)
                    .execute()
                    .getOutputAs(AccessorsClassPath::class.java)
                    .get()
            }
            ?: AccessorsClassPath.empty

    private
    val catalogExtensionBaseType = typeOf<ExternalModuleDependencyFactory>()

    private
    fun generatePluginSpecBuildersAccessors(

            on { accessorsClassPathFor(any()) } doReturn accessorsClassPath
            on { hashOf(eq(accessorsClassPath)) } doReturn accessorsClassPathHash

            on {
                loadClassInChildScopeOf(any(), any(), any(), any(), any(), same(accessorsClassPath))
            } doAnswer {

                val location = it.getArgument<File>(3)

            origin = ClassLoaderScopeOrigin.Script(scriptSource.fileName, scriptSource.longDisplayName, scriptSource.shortDisplayName),
            accessorsClassPath = accessorsClassPath,
            location = classesDir,
            className = "Program"
        )
    }

    private
    val defaultProgramHost = ProgramHost()

    private

        val target = mock<Project>()
        val scriptHost = scriptHostWith(target)
        val accessorsClassPath = mock<ClassPath>()
        val programHost = safeMockProgramHost {
            on { accessorsClassPathFor(scriptHost) } doReturn accessorsClassPath
        }

        withExecutableProgramFor(
            Dynamic(Static(ApplyDefaultPluginRequests, ApplyBasePlugins), source),

            sourceHash: HashCode,
            accessorsClassPath: ClassPath
        )

        fun compileSecondStageOf(
            program: StagedProgram,
            scriptHost: KotlinScriptHost<*>,
            programId: ProgramId,
            programKind: ProgramKind,
            programTarget: ProgramTarget,
            accessorsClassPath: ClassPath
        ): CompiledScript

                myProperty = 42
            }

            println(mySettingsExtension.myProperty)
        """)

        when:
        def accessorsClassPath = accessorsClassPathFor(settingsFileKts)

        then:
        !accessorsClassPath.isEmpty()
    }

    private List<File> accessorsClassPathFor(File buildFile) {
        return classPathFor(projectDir, buildFile)
            .tap { println(it) }

            accessorsClassPath: ClassPath,
            initializer: (File) -> Unit
        ): File = try {
            executionEngineFor(scriptHost)
                .createRequest(
                    KotlinScriptCompilationAndInstrumentation(
                        programId,
                        compilationClassPath,
                        accessorsClassPath,
                        initializer,