return provider.calculateValue(consumer).withSideEffect(sideEffect);
    }

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

    @Override
    public ProviderInternal<T> withSideEffect(@Nullable SideEffect<? super T> sideEffect) {
        if (sideEffect == null) {

        def source = getSource()

        when:
        def provider1 = Providers.of("v1").withSideEffect(sideEffect1)
        source.addPending(provider1)
        def provider2 = Providers.of("v2").withSideEffect(sideEffect2)
        source.addPending(provider2)
        def provider3 = Providers.of("v3").withSideEffect(sideEffect3)
        source.addPending(provider3)
        def provider4 = propertyFactory.listProperty(String).with {

        def mergedSideEffect = Mock(ValueSupplier.SideEffect)

        def left = Providers.of("left").withSideEffect(leftSideEffect)
        def right = Providers.of("right").withSideEffect(rightSideEffect)

        def provider = new MergeProvider([left, right]).withSideEffect(mergedSideEffect)

        when:
        provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)

    }

    @Override
    public Provider<JavaCompiler> compilerFor(JavaToolchainSpec spec) {
        return queryService.findMatchingToolchain(spec)
            .withSideEffect(toolchain -> emitEvent(toolchain, JavaTool.COMPILER))
            .map(javaToolchain -> new DefaultToolchainJavaCompiler(javaToolchain, compilerFactory));
    }

    @Override

            return Value.ofNullable(combinedUnpackedValue)
                .withSideEffect(SideEffect.fixedFrom(leftValue))
                .withSideEffect(SideEffect.fixedFrom(rightValue));
        }
    }

    @Nullable
    @Override
    public Class<R> getType() {
        return type;
    }

    @Override

            if (value.isMissing()) {
                return value.asType();
            }
            collector.add(key, value.getWithoutSideEffect(), dest);
            return Value.present().withSideEffect(SideEffect.fixedFrom(value));
        }

        @Override
        public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collector, ImmutableCollection.Builder<K> dest) {

            result.add(value.getWithoutSideEffect());
        }

        Value<List<R>> finalValue = Value.ofNullable(result.build());
        for (Value<? extends R> value : values) {
            finalValue = finalValue.withSideEffect(SideEffect.fixedFrom(value));
        }

        return finalValue;
    }

    @Nullable
    @Override
    public Class<List<R>> getType() {
        return Cast.uncheckedCast(List.class);
    }

        // as the transformed provider can have side effects hidden under other wrapping providers.
        return Providers.internal(transformedProvider).withSideEffect(SideEffect.fixedFrom(value));
    }

    private ProviderInternal<? extends S> backingProvider(EvaluationContext.ScopeContext context, ValueConsumer consumer) {

        } else {
            ProviderInternal<T> provider = of(value.getWithoutSideEffect());
            ValueSupplier.SideEffect<?> sideEffect = value.getSideEffect();
            return sideEffect == null ? provider : provider.withSideEffect(Cast.uncheckedCast(sideEffect));
        }
    }

    public static <T> ProviderInternal<T> notDefined() {
        return Cast.uncheckedCast(NULL_PROVIDER);
    }