hierarchyByName.put(attribute.getName(), this);
        this.hierarchyByName = ImmutableMap.copyOf(hierarchyByName);
        int hashCode = parent.hashCode();
        hashCode = 31 * hashCode + attribute.hashCode();
        hashCode = 31 * hashCode + value.hashCode();
        this.hashCode = hashCode;
        if (hierarchyByName.size() == 1) {

            return Objects.equal(identifierSerializer, rhs.identifierSerializer);
        }

        @Override
        public int hashCode() {
            return Objects.hashCode(super.hashCode(), identifierSerializer);
        }
    }

    private static class ModuleArtifactsCacheEntrySerializer extends AbstractSerializer<ModuleArtifactsCacheEntry> {

class GenericArrayTypeWrapper implements TypeWrapper {
    private final TypeWrapper componentType;
    private final int hashCode;

    public GenericArrayTypeWrapper(TypeWrapper componentType, int hashCode) {
        this.componentType = componentType;
        this.hashCode = hashCode;
    }

    public TypeWrapper getComponentType() {
        return componentType;
    }

    @Override

    private final HashCode implementationHash;
    private final byte[] serializedValue;

    public GradleSerializedValueSnapshot(
        @Nullable HashCode implementationHash,
        byte[] serializedValue
    ) {
        this.implementationHash = implementationHash;
        this.serializedValue = serializedValue;
    }

    @Nullable
    public HashCode getImplementationHash() {

    this.validator = validator;
    this.errorMessage = errorMessage;
  }

  // Override hashCode() to access delegate directly (so that it doesn't trigger the validate() call
  // via delegate()); it seems inappropriate to throw ISE on this method.
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  private void validate() {

 */

package org.gradle.internal.snapshot.impl;

import org.gradle.internal.hash.HashCode;
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;

    @Nullable
    @Override
    public HashCode hash(RegularFileSnapshotContext snapshotContext) throws IOException {
        return Optional.of(snapshotContext)
            .filter(this::filter)
            .flatMap(path -> tryHash(snapshotContext))
            .orElseGet(IoSupplier.wrap(() -> delegate.hash(snapshotContext)));
    }

    @Nullable
    @Override
    public HashCode hash(ZipEntryContext zipEntryContext) throws IOException {

    }

    def "hashCode semantics"() {
        given:
        def a = new TypeOf() {}.hashCode()
        def b = new TypeOf<List>() {}.hashCode()
        def c = new TypeOf<List<String>>() {}.hashCode()

        expect:
        a != b
        b != c
        c != a

        and:
        a == new TypeOf() {}.hashCode()
        b == new TypeOf<List>() {}.hashCode()

        encoder.writeByte((byte) accessType.ordinal());
    }

    private static HashCode readHashCode(Decoder decoder) throws IOException {
        return HashCode.fromBytes(decoder.readBinary());
    }

    private static void writeHashCode(Encoder encoder, HashCode hashCode) throws IOException {
        encoder.writeBinary(hashCode.toByteArray());
    }

    private static class SnapshotStack {

    /**
     * Hash the given bytes using the hash function.
     */
    HashCode hashBytes(byte[] bytes);

    /**
     * Hash the given string using the hash function.
     */
    HashCode hashString(CharSequence string);

    /**
     * Hash the contents of the given {@link java.io.InputStream}.
     */
    HashCode hashStream(InputStream stream) throws IOException;

    /**