import org.gradle.internal.scan.UsedByScanPlugin;

import java.io.Serializable;

/**
 * The source for the text of a script, with some meta-info about the script.
 */
@UsedByScanPlugin
public interface ScriptSource extends Serializable {
    /**
     * Returns the name to use for the compiled class for this script. Never returns null.
     */
    String getClassName();

    /**

        accessorsClassPath: ClassPath,
        scriptSource: ScriptSource
    ): CompiledScript {

        logClassLoadingOf(scriptTemplateId, scriptSource)

        return host.loadClassInChildScopeOf(
            baseScope,
            childScopeId = classLoaderScopeIdFor(scriptPath, scriptTemplateId),
            origin = ClassLoaderScopeOrigin.Script(scriptSource.fileName, scriptSource.longDisplayName, scriptSource.shortDisplayName),

    private final ScriptSource scriptSource;
    private final Integer lineNumber;

    public ScriptCompilationException(String message, Throwable cause, ScriptSource scriptSource, Integer lineNumber) {
        super(message, cause);
        this.scriptSource = scriptSource;
        this.lineNumber = lineNumber;
    }

    public ScriptSource getScriptSource() {
        return scriptSource;
    }

    private final Spec<? super Statement> filter;
    private final ScriptSource scriptSource;

    private final ImperativeStatementDetectingTransformer imperativeStatementDetectingTransformer = new ImperativeStatementDetectingTransformer();

    public BuildScriptTransformer(ScriptSource scriptSource, ScriptTarget scriptTarget) {

import spock.lang.Specification

class DefaultScriptPluginFactoryTest extends Specification {

    def scriptCompilerFactory = Mock(ScriptCompilerFactory)
    def scriptCompiler = Mock(ScriptCompiler)
    def scriptSource = Mock(ScriptSource)
    def scriptRunner = Mock(ScriptRunner)
    def script = Mock(BasicScript)
    def targetScope = Mock(ClassLoaderScope)
    def baseScope = Mock(ClassLoaderScope)

        final ScriptSource scriptSource = scriptSource(scriptText)
        def sourceHashCode = hashFor(scriptText)

        when:
        scriptCompilationHandler.compileToDir(scriptSource, classLoader, scriptCacheDir, metadataCacheDir, null, expectedScriptClass, verifier)

        then:
        checkScriptClassesInCache(true)

        when:

        def scriptSource = Stub(ScriptSource)
        def resource = Stub(TextResource)

        scriptSource.resource >> resource
        resource.contentCached >> false

        expect:
        def wrapper = CachingScriptSource.of(scriptSource)
        wrapper instanceof CachingScriptSource
        wrapper.source == scriptSource
    }

        }
    }

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

        given:
        def scriptSource = scriptSourceFor(fileName)
        def target = new Object()

        when:
        def scriptPlugin = selector.create(scriptSource, scriptHandler, targetScope, baseScope, false)

        and:
        scriptPlugin.apply(target)

        then:
        1 * defaultScriptPlugin.source >> scriptSource
        1 * defaultScriptPlugin.apply(target)

        where:

 */

package org.gradle.groovy.scripts.internal;

import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.hash.HashCode;

public class DefaultScriptSourceHasher implements ScriptSourceHasher {

    @Override
    public HashCode hash(ScriptSource scriptSource) {
        return scriptSource.getResource().getContentHash();
    }