data object SchemaNotBuilt : InterpretationSchemaBuildingResult
}


sealed interface DeclarativeScriptContext {
    interface SettingsScript : DeclarativeScriptContext

    object ProjectScript : DeclarativeScriptContext

    object UnknownScript : DeclarativeScriptContext

        DeclarativeScriptContext.ProjectScript -> InterpretationSchemaBuildingResult.InterpretationSequenceAvailable(projectSequence)
        is DeclarativeScriptContext.SettingsScript -> InterpretationSchemaBuildingResult.InterpretationSequenceAvailable(settingsSequence)
        DeclarativeScriptContext.UnknownScript -> InterpretationSchemaBuildingResult.SchemaNotBuilt
    }

    private
    fun scriptContextFromFileName(fileName: String) = when (File(fileName).name) {
        "build.gradle.dcl" -> DeclarativeScriptContext.ProjectScript
        "settings.gradle.dcl" -> object : DeclarativeScriptContext.SettingsScript {}
        else -> DeclarativeScriptContext.UnknownScript
    }

        val settings = target.mutableModel.settings
        val settingsContext = LoadedSettingsScriptContext(settings, settings.classLoaderScope, settings.settingsScript)

        val settingsSequence = schemaBuilder.getEvaluationSchemaForScript(settingsContext)
            .sequenceOrError().analysisOnly()

    )

    return NonProjectScriptModel(
        initScript,
        scriptClassPath,
        sourcePathFor(listOf(scriptHandler)),
    )
}


private
fun buildSettingsScriptModel(settingsScript: File, rootProject: Project): NonProjectScriptModel {
    val settings = rootProject.settings
    val scriptCompilationClassPath = settings.scriptCompilationClassPath

                    }
                }
            }
        """
        expect:
        succeeds 'help', '-PrepoUrl=some/place'

    }

    def "Can access SettingsScript API in pluginManagement block"() {
        given:
        settingsFile << """
            pluginManagement {
                repositories {
                    maven {
                        url file('bar')

    gradle.startParameter.allInitScripts
        .filter { it.isKotlinDslFile }


internal
fun Project.discoverSettingScript(): File? =
    File((this as ProjectInternal).gradle.settings.settingsScript.fileName)
        .takeIf { it.isKotlinDslFile }


internal
fun Project.discoverBuildScript(): File? =
    buildFile.takeIf { it.isKotlinDslFile }


internal

            else -> projectScriptPluginModelBuilder(scriptFile, modelRequestProject)
        }
    }

    private
    fun isSettingsFileOf(project: Project, scriptFile: File): Boolean =
        project.settings.settingsScript.resource.file?.canonicalFile == scriptFile

    private
    fun requestParameterOf(modelRequestProject: Project) =
        KotlinBuildScriptModelParameter(

        require(rootBuild.gradle.owner is RootBuildState)
        val gradle = rootBuild.gradle
        withDebugFrame({ "Gradle" }) {
            write(gradle.settings.settingsScript.resource.location.file)
            writeBuildTreeScopedState(gradle)
        }
        val buildEventListeners = buildEventListenersOf(gradle)
        writeBuildsInTree(rootBuild, buildEventListeners)
    }

            tasks.register("printMessage") { doLast { println (new org.gradle.test.BuildClass().message()) } }
        """}

        settingsScript("""
            include "reproducible", "current"
        """)

        file("reproducible/build.gradle").text = subprojectSource(reproducibleJar)