* limitations under the License.
 */

package org.gradle.groovy.scripts.internal;

/**
 * Data extracted from a build script at compile time.
 */
public class BuildScriptData {
    private final boolean hasImperativeStatements;

    public BuildScriptData(boolean hasImperativeStatements) {
        this.hasImperativeStatements = hasImperativeStatements;
    }

    /**

import org.gradle.internal.serialize.Encoder;

public class BuildScriptDataSerializer extends AbstractSerializer<BuildScriptData> {
    @Override
    public BuildScriptData read(Decoder decoder) throws Exception {
        return new BuildScriptData(decoder.readBoolean());
    }

    @Override
    public void write(Encoder encoder, BuildScriptData value) throws Exception {
        encoder.writeBoolean(value.getHasImperativeStatements());
    }

import org.gradle.groovy.scripts.ScriptCompilerFactory
import org.gradle.groovy.scripts.ScriptRunner
import org.gradle.groovy.scripts.ScriptSource
import org.gradle.groovy.scripts.internal.BuildScriptData
import org.gradle.groovy.scripts.internal.NoDataCompileOperation
import org.gradle.internal.Factory
import org.gradle.internal.classloader.ClasspathHasher
import org.gradle.internal.classpath.ClassPath

        imperativeStatementDetectingTransformer.register(compilationUnit);
    }

    @Override
    public BuildScriptData create() {
        return new BuildScriptData(imperativeStatementDetectingTransformer.isImperativeStatementDetected());
    }

import org.gradle.configuration.CompileOperationFactory;
import org.gradle.configuration.ScriptTarget;
import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.groovy.scripts.internal.BuildScriptData;
import org.gradle.groovy.scripts.internal.BuildScriptDataSerializer;
import org.gradle.groovy.scripts.internal.BuildScriptTransformer;
import org.gradle.groovy.scripts.internal.CompileOperation;

import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.groovy.scripts.internal.BuildScriptData;
import org.gradle.groovy.scripts.internal.CompileOperation;

public interface CompileOperationFactory {
    CompileOperation<?> getPluginsBlockCompileOperation(ScriptTarget initialPassScriptTarget);

    CompileOperation<BuildScriptData> getScriptCompileOperation(ScriptSource scriptSource, ScriptTarget scriptTarget);

            scriptType = scriptTarget.getScriptClass();

            CompileOperation<BuildScriptData> operation = compileOperationFactory.getScriptCompileOperation(scriptSource, scriptTarget);

            final ScriptRunner<? extends BasicScript, BuildScriptData> runner = compiler.compile(scriptType, target, targetScope, operation, ClosureCreationInterceptingVerifier.INSTANCE);

import org.gradle.api.tasks.SkipWhenEmpty;
import org.gradle.api.tasks.TaskAction;
import org.gradle.configuration.CompileOperationFactory;
import org.gradle.configuration.ScriptTarget;
import org.gradle.groovy.scripts.internal.BuildScriptData;
import org.gradle.groovy.scripts.internal.CompileOperation;
import org.gradle.groovy.scripts.internal.ScriptCompilationHandler;
import org.gradle.initialization.ClassLoaderScopeRegistry;

class BuildScriptDataSerializerTest extends SerializerSpec {
    def serializer = new BuildScriptDataSerializer()

    def "serializes data"() {
        given:
        def value = new BuildScriptData(true)
        def result = serialize(value, serializer)

        expect:
        result.hasImperativeStatements
    }

        scriptCacheDir = new File(testProjectDir, "cache")
        metadataCacheDir = new File(testProjectDir, "metadata")
    }

    private CompiledScript<Script, BuildScriptData> parse(String script) {
        def source = new TextResourceScriptSource(new StringTextResource("test script", script))
        def sourceHashCode = Hashing.hashString(script)
        def target = Mock(ScriptTarget) {