}

    override fun externalProcessStarted(command: String, consumer: String) {
        if (Workarounds.canStartExternalProcesses(consumer)) {
            return
        }
        externalProcessListener.onExternalProcessStarted(command, consumer)
    }

    override fun fileOpened(file: File, consumer: String) {
        if (Workarounds.canReadFiles(consumer)) {
            return

    void fileObserved(File file, String consumer);

    void fileSystemEntryObserved(File file, String consumer);

    void directoryContentObserved(File file, String consumer);

        @Override
        public boolean calculatePresence(ValueConsumer consumer) {
            return providerOfValue.calculatePresence(consumer);
        }

        @Override
        public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
            Value<? extends V> value = providerOfValue.calculateValue(consumer);
            if (value.isMissing()) {

            where:
            consumer << throwingConsumers()
        }

        def "calling #consumer is safe even if user code causes circular evaluation"(
            Consumer<ProviderInternal<?>> consumer
        ) {
            given:
            def provider = providerWithSelfReference()

            when:
            consumer.accept(provider)

            then:

            )
        }
    }

    @Test
    fun `kotlin-dsl java and groovy consumers can use kotlin interface default methods directly`() {

        file("settings.gradle.kts").appendText(
            """
            include("kotlin-dsl-producer")
            include("java-consumer")
            include("groovy-consumer")
            """
        )

    @Override
    public void externalProcessStarted(String command, String consumer) {}

    @Override
    public void fileOpened(File file, String consumer) {}

    @Override
    public void fileObserved(File file, String consumer) {}

    @Override
    public void fileSystemEntryObserved(File file, String consumer) {}

    @Override
    public void directoryContentObserved(File file, String consumer) {}

        } else {
            locationForCaller(consumer, diagnostics.source)
        }
    }

    private
    fun locationForCaller(consumer: String?, source: UserCodeSource?): PropertyTrace {
        return if (source != null) {
            PropertyTrace.BuildLogic(source.displayName, null)
        } else if (consumer != null) {
            PropertyTrace.BuildLogicClass(consumer)
        } else {

     */
    fun systemPropertyRead(key: String, value: Any?, consumer: String?)

    fun envVariableRead(key: String, value: String?, consumer: String?)

    fun fileOpened(file: File, consumer: String?)

    fun fileObserved(file: File, consumer: String?)

    fun fileSystemEntryObserved(file: File, consumer: String?)

    fun directoryChildrenObserved(directory: File, consumer: String?)

    }

    @Override
    public boolean calculatePresence(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            return backingProvider(context, consumer).calculatePresence(consumer);
        }
    }

    @Override
    protected Value<? extends S> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {

    public boolean calculatePresence(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            if (!left.calculatePresence(consumer) || !right.calculatePresence(consumer)) {
                return false;
            }
        }
        // Purposefully only calculate full value if left & right are both present, to save time
        return super.calculatePresence(consumer);
    }

    @Override