}

    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

            )
        }
    }

    @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")
            """
        )

        } 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?)

@EventScope(Scope.BuildTree::class)
interface ProblemFactory {
    /**
     * Returns a default location inferred from the calling thread's state.
     */
    fun locationForCaller(consumer: String? = null): PropertyTrace

    /**
     * Creates a problem with the given message and exception.
     *
     * Problem has no documentation, and a default location is inferred from the calling thread's state.

) : ExecutionAccessChecker {
    override fun disallowedAtExecutionInjectedServiceAccessed(injectedServiceType: Class<*>, getterName: String, consumer: String) {
        if (shouldReportExecutionTimeAccess()) {
            broadcaster.disallowedAtExecutionInjectedServiceAccessed(injectedServiceType, getterName, consumer)
        }
    }

    private
    fun shouldReportExecutionTimeAccess(): Boolean =

            include("consumer", "producer")
            """
        )

        withBuildScript(
            """
            plugins {
                `java-library`
            }

            allprojects {
                $repositoriesBlock
            }

            dependencies {
                api(project(":consumer"))
            }
            """
        )

                    "producer.plugin.gradle.kts",
                    """extensions.add("answer", 42)"""
                )
            }
            // a consumer of the precompiled script plugin extension
            "consumer/src/main/kotlin" {
                withFile(
                    "consumer.plugin.gradle.kts",
                    """
                        plugins { id("producer.plugin") }
                        println(answer)

) : InstrumentedExecutionAccess.Listener {

    override fun disallowedAtExecutionInjectedServiceAccessed(injectedServiceType: Class<*>, propertyName: String, consumer: String) {
        executionAccessChecker.disallowedAtExecutionInjectedServiceAccessed(injectedServiceType, propertyName, consumer)
    }

) : ConfigurationCacheProblemsListener {

    override fun disallowedAtExecutionInjectedServiceAccessed(injectedServiceType: Class<*>, getterName: String, consumer: String) {
        val problem = problemFactory.problem(consumer) {
            text("accessing non-serializable type ")
            reference(injectedServiceType)
            text(" caused by invocation ")
            reference(getterName)
        }