this.afterExecutionOutputState = afterExecutionOutputState;
        }

        @Override
        public ImplementationSnapshot getImplementation() {
            return beforeExecutionState.getImplementation();
        }

        @Override
        public ImmutableList<ImplementationSnapshot> getAdditionalImplementations() {
            return beforeExecutionState.getAdditionalImplementations();
        }

import org.gradle.internal.hash.Hashing;
import org.gradle.internal.operations.trace.CustomOperationTraceSerialization;
import org.gradle.internal.scan.UsedByScanPlugin;
import org.gradle.internal.snapshot.impl.ImplementationSnapshot;
import org.gradle.operations.execution.FilePropertyVisitor;

import javax.annotation.Nullable;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Deque;

        @Override
        public ValueSnapshot classValue(Class<?> value) {
            return ImplementationSnapshot.of(value, classLoaderHasher);
        }

        @Override
        public ValueSnapshot implementationValue(String implementationClassIdentifier, Object implementation) {
            return ImplementationSnapshot.of(
                implementationClassIdentifier,
                implementation,

import org.gradle.internal.hash.Hasher;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.Objects;

public class ClassImplementationSnapshot extends ImplementationSnapshot {
    private final HashCode classLoaderHash;

    public ClassImplementationSnapshot(String classIdentifier, HashCode classLoaderHash) {
        super(classIdentifier);
        this.classLoaderHash = classLoaderHash;

import org.gradle.internal.execution.history.PreviousExecutionState
import org.gradle.internal.hash.TestHashCodes
import org.gradle.internal.snapshot.FileSystemSnapshot
import org.gradle.internal.snapshot.impl.ImplementationSnapshot

import static org.gradle.internal.execution.ExecutionEngine.Execution

class StoreExecutionStateStepTest extends StepSpec<IncrementalCachingContext> implements SnapshotterFixture {

    }

    @Override
    public void appendToHasher(Hasher hasher) {
        hasher.putString(getValue().getName());
        Class<?> type = getValue().getType();
        ImplementationSnapshot.of(type, classLoaderHasher).appendToHasher(hasher);
    }

    def action1 = Mock(InputChangesAwareTaskAction) {
        getActionImplementation(_ as ClassLoaderHierarchyHasher) >> ImplementationSnapshot.of("Action1", TestHashCodes.hashCodeFrom(1234))
    }
    def action2 = Mock(InputChangesAwareTaskAction) {
        getActionImplementation(_ as ClassLoaderHierarchyHasher) >> ImplementationSnapshot.of("Action2", TestHashCodes.hashCodeFrom(1234))
    }
    def state = new TaskStateInternal()

import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hasher;

import javax.annotation.Nullable;
import java.util.Objects;

public class UnknownImplementationSnapshot extends ImplementationSnapshot {

    public enum UnknownReason {
        UNKNOWN_CLASSLOADER(
            "was loaded with an unknown classloader (class '%s').",

import org.gradle.internal.hash.Hasher;

import javax.annotation.Nullable;
import java.lang.invoke.SerializedLambda;
import java.util.Objects;

public class LambdaImplementationSnapshot extends ImplementationSnapshot {

    private final HashCode classLoaderHash;

    private final String functionalInterfaceClass;
    private final String implClass;
    private final String implMethodName;

        }
    }

    private static ImplementationSnapshot getActionImplementation(Object value, ClassLoaderHierarchyHasher hasher) {
        HashCode classLoaderHash = hasher.getClassLoaderHash(value.getClass().getClassLoader());
        String actionClassIdentifier = ScriptOriginUtil.getOriginClassIdentifier(value);
        return ImplementationSnapshot.of(actionClassIdentifier, value, classLoaderHash);
    }