}
    }

    private
    fun runInterpretationSequence(
        scriptSource: ScriptSource,
        sequence: InterpretationSequence,
        target: Any
    ): EvaluationResult<ConversionStepResult> =
        sequence.steps.map { step ->

    override fun create(
        scriptSource: ScriptSource,
        scriptHandler: ScriptHandler,
        targetScope: ClassLoaderScope,
        baseScope: ClassLoaderScope,
        topLevelScript: Boolean
    ): ScriptPlugin =
        DeclarativeDslPlugin(scriptSource) { target ->
            when (val result = declarativeKotlinScriptEvaluator.evaluate(target, scriptSource, targetScope)) {

internal
class PluginsInterpretationSequenceStep(
    stepIdentifierString: String = "plugins",
    private val targetScope: ClassLoaderScope,
    private val scriptSource: ScriptSource,
    private val getTargetServices: () -> ServiceRegistry,
) : InterpretationSequenceStepWithConversion<PluginsTopLevelReceiver> {

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

}


data class LoadedSettingsScriptContext(
    val settings: SettingsInternal,
    val targetScope: ClassLoaderScope,
    val scriptSource: ScriptSource

import org.gradle.plugin.software.internal.SoftwareTypeRegistry


internal
fun settingsInterpretationSequence(
    settings: SettingsInternal,
    targetScope: ClassLoaderScope,
    scriptSource: ScriptSource,
    softwareTypeRegistry: SoftwareTypeRegistry
): InterpretationSequence =
    DefaultInterpretationSequence(
        listOf(

 * limitations under the License.
 */

package org.gradle.internal.extensions.core

import org.gradle.groovy.scripts.ScriptSource
import java.net.URI


/**
 * Same as `resource.location.uri`.
 */
val ScriptSource.uri: URI?

        AssignmentTracer { AssignmentResolver() }.produceAssignmentTrace(result)

    private
    fun languageModelFromLightParser(scriptIdentifier: String, scriptSource: String): LanguageTreeResult {
        val parsedTree = parse(scriptSource)
        return languageTreeBuilder.build(parsedTree, SourceIdentifier(scriptIdentifier))
    }

    private
    val languageTreeBuilder = DefaultLanguageTreeBuilder()

        supportedResolutionResultHandlers = listOf(ConventionDefinitionCollector(conventionStorage), ConventionApplicationHandler(conventionStorage))
    )

    fun evaluate(
        scriptFileName: String,
        scriptSource: String
    ): AnalysisSequenceResult {
        val scriptContext = scriptContextFromFileName(scriptFileName)
        return when (val built = schemaBuilder.getEvaluationSchemaForScript(scriptContext)) {

import org.gradle.api.internal.project.ProjectRegistry;
import org.gradle.caching.configuration.internal.BuildCacheConfigurationInternal;
import org.gradle.declarative.dsl.model.annotations.Adding;
import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.initialization.DefaultProjectDescriptor;
import org.gradle.initialization.IncludedBuildSpec;
import org.gradle.internal.FinalizableValue;