/**
 * Represents a calculated immutable value that is calculated once and then consumed by multiple threads.
 * <p>
 * This class can hold a null value.
 */
@ThreadSafe
public interface CalculatedValue<T> {
    // TODO(https://github.com/gradle/gradle/issues/24767): with JSpecify, the nullable nature of the type argument <T> should be expressed as <T extends @Nullable Object>.

    /**

        createProject(state2, project2)
        def calculatedValue = state1.newCalculatedValue("initial")

        when:
        calculatedValue.set("bad")

        then:
        thrown(IllegalStateException)
        calculatedValue.get() == "initial"

        when:
        state1.applyToMutableState {
            calculatedValue.set("updated")
        }

        then:

    private final ImmutableCapabilities capabilities;
    private final CalculatedValue<ConfigurationDependencyMetadata> dependencies;

    // TODO: Move all this lazy artifact stuff to a "State" type.
    private final Set<LocalVariantMetadata> variants;
    private final CalculatedValueContainerFactory factory;
    private final CalculatedValue<ImmutableList<LocalComponentArtifactMetadata>> artifacts;

import org.gradle.api.artifacts.component.ComponentArtifactIdentifier;
import org.gradle.api.internal.tasks.TaskDependencyContainer;
import org.gradle.internal.component.model.IvyArtifactName;
import org.gradle.internal.model.CalculatedValue;

import java.io.File;

/**
 * Represents an artifact that can be resolved. Call {@link #getFile()} or {@link ResolvedArtifact#getFile()} to resolve.
 */

import java.util.function.Supplier;

/**
 * A factory for {@link CalculatedValue}.
 */
@ServiceScope(Scope.BuildSession.class)
public interface CalculatedValueFactory {
    /**
     * Creates a calculated value that has no dependencies and that does not access any mutable model state.
     */
    <T> CalculatedValue<T> create(DisplayName displayName, Supplier<? extends T> supplier);

    /**

import org.gradle.internal.component.model.VariantResolveMetadata;
import org.gradle.internal.model.CalculatedValue;

/**
 * Implementation of {@link VariantResolveMetadata} which allows variant artifacts to be calculated lazily
 * while holding a project lock.
 */
public final class LocalVariantMetadata extends DefaultVariantMetadata {
    private final CalculatedValue<ImmutableList<LocalComponentArtifactMetadata>> artifacts;

        CalculatedValue<DefaultLocalConfigurationMetadata.ConfigurationDependencyMetadata> dependencies =
            getConfigurationDependencyState(description, hierarchy, attributes, configurationsProvider, dependencyCache, model, calculatedValueContainerFactory);

        CalculatedValue<ImmutableList<LocalComponentArtifactMetadata>> artifacts =

import org.gradle.internal.component.model.DefaultIvyArtifactName;
import org.gradle.internal.component.model.IvyArtifactName;
import org.gradle.internal.model.CalculatedValue;
import org.gradle.internal.model.CalculatedValueFactory;

import javax.annotation.Nullable;
import java.io.File;

public class DefaultResolvableArtifact implements ResolvableArtifact {

import org.gradle.api.artifacts.component.ComponentArtifactIdentifier
import org.gradle.api.internal.tasks.TaskDependencyContainer
import org.gradle.internal.component.model.IvyArtifactName
import org.gradle.internal.model.CalculatedValue
import org.gradle.util.Matchers
import org.gradle.util.TestUtil
import spock.lang.Specification

class DefaultResolvableArtifactTest extends Specification {

import org.gradle.internal.component.model.DefaultIvyArtifactName;
import org.gradle.internal.component.model.IvyArtifactName;
import org.gradle.internal.model.CalculatedValue;
import org.gradle.internal.model.CalculatedValueFactory;

import javax.annotation.Nullable;
import java.io.File;

public class PreResolvedResolvableArtifact implements ResolvableArtifact {