}

    @Override
    protected Value<? extends T> calculateValueFrom(EvaluationContext.ScopeContext context, ProviderInternal<? extends T> value, ValueConsumer consumer) {
        return value.calculateValue(consumer);
    }

    @Override
    protected ProviderInternal<? extends T> finalValue(EvaluationContext.ScopeContext context, ProviderInternal<? extends T> value, ValueConsumer consumer) {

        public NoValueProvider(Value<? extends T> value) {
            assert value.isMissing();
            this.value = value;
        }

        @Override
        public Value<? extends T> calculateValue(ValueConsumer consumer) {
            return value;
        }

        @Override
        public boolean isImmutable() {
            return true;
        }

        @Nullable
        @Override

            context.add(transformStep);
            context.add(upstreamDependencies);
        }

        @Override
        public TransformStepSubject calculateValue(NodeExecutionContext context) {
            TransformStepBuildOperation buildOperation = createBuildOperation(context);
            ProjectInternal owningProject = transformStep.getOwningProject();

                    if (effectiveContext == null) {
                        effectiveContext = new GlobalContext(defaultContext);
                    }
                    return supplier.calculateValue(effectiveContext);
                });
                owner.calculationState = null;
            } finally {
                releaseLock();
            }
        }

    }

    def callsRemoveActionWhenObjectRemovedUsingIteratorNoFlushAndLastElementIsUnrealized() {
        def action = Mock(Action)
        def provider = Mock(ProviderInternal)
        _ * provider.calculateValue(_) >> ValueSupplier.Value.of("c")

        container.whenObjectRemoved(action)
        container.add("a")
        container.add("b")
        container.addLater(provider)

        public abstract FileCollection selectedArtifacts();

        @Override
        public TransformDependencies calculateValue(NodeExecutionContext context) {
            FileCollection files = selectedArtifacts();
            // Trigger resolution, including any failures
            files.getFiles();

    @Override
    <S> ProviderInternal<S> map(Transformer<? extends S, ? super T> transformer);

    /**
     * Calculates the current value of this provider.
     */
    ValueSupplier.Value<? extends T> calculateValue(ValueConsumer consumer);

    /**
     * Returns a view of this provider that can be used to supply a value to a {@link org.gradle.api.provider.Property} instance.
     */

        // `PropertyInternal` does not directly provide these setters,
        // but all user-facing interfaces and their implementations do.
        property."$setter"(providerWithSideEffect)

        property.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)
        property.calculateExecutionTimeValue()

        then:
        0 * _ // no side effects when calling setter or calculated values are not unpacked

                        context.add(value.getTaskDependencies());
                    }
                });
            }
        }

        @Override
        public IsolatedParameters calculateValue(NodeExecutionContext context) {
            InputFingerprinter inputFingerprinter = context.getService(InputFingerprinter.class);
            return isolateParameters(inputFingerprinter);
        }

/**
 * 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>.

    /**