return super.calculatePresence(consumer);
    }

    @Override
    public ExecutionTimeValue<? extends R> calculateExecutionTimeValue() {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            if (isChangingValue(left) || isChangingValue(right)) {
                return ExecutionTimeValue.changingValue(this);
            }
        }
        return super.calculateExecutionTimeValue();
    }

        return super.calculatePresence(consumer);
    }

    @Override
    public ExecutionTimeValue<? extends List<R>> calculateExecutionTimeValue() {
        for (Provider<R> provider : items) {
            if (isChangingValue(Providers.internal(provider))) {
                return ExecutionTimeValue.changingValue(this);
            }
        }

        return super.calculateExecutionTimeValue();
    }

    @Override
    public Object unpackState() {
        throw new UnsupportedOperationException("Build services cannot be serialized.");
    }

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
        return ExecutionTimeValue.changingValue(this);
    }

    public void maybeStop() {
        // subclasses to override
    }

    @SuppressWarnings("unused") // Used via instrumentation

        }
    }

    suspend fun WriteContext.encodeContents(value: FileCollectionInternal) {
        val executionTimeValue = value.calculateExecutionTimeValue().getOrNull()
        if (executionTimeValue != null) {
            writeBoolean(true)
            write(executionTimeValue)
        } else {
            writeBoolean(false)
            encodeViaCollectingVisitor(value)
        }
    }

    private

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            ExecutionTimeValue<? extends T> value = calculateOwnExecutionTimeValue(context, this.value);
            if (getProducerTask() == null) {
                return value;

    Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> dest);

    int size();

    void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor);

    /**
     * Returns a view of this collector that never returns a missing value.
     */
    Collector<T> absentIgnoring();

    /**

     */
    MapSupplier<K, V> absentIgnoring();

    default MapSupplier<K, V> absentIgnoringIfNeeded(boolean required) {
        return required ? absentIgnoring() : this;
    }

    ExecutionTimeValue<? extends Map<K, V>> calculateExecutionTimeValue();

    Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collector, ImmutableCollection.Builder<K> dest);

    void calculateExecutionTimeValue(Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> visitor);

    MapCollector<K, V> absentIgnoring();

    /**
     * Returns a collector that may never return a missing value.
     */

            return null;
        }

        @Override
        public ExecutionTimeValue<T> calculateExecutionTimeValue() {
            if (value.hasBeenObtained()) {
                return ExecutionTimeValue.ofNullable(value.obtain().get());
            } else {
                return ExecutionTimeValue.changingValue(this);
            }
        }

        @Override

    }

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        return provider.calculateValue(consumer).withSideEffect(sideEffect);
    }

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
        return provider.calculateExecutionTimeValue().withSideEffect(sideEffect);
    }

    @Override