Transformer<E, Throwable> onError) {
            if (checkToHandleDisabledRepository(result, onDisabled)) {
                return;
            }
            tryResolveAndMaybeDisable(result, operation, onError);
        }

        private <E extends Throwable, R extends ErroringResolveResult<E>> void performOperationWithRetries(R result,

import org.gradle.internal.configuration.problems.StructuredMessageBuilder
import java.io.IOException


abstract class AbstractProblemsListener : ProblemsListener {

    override fun onError(trace: PropertyTrace, error: Exception, message: StructuredMessageBuilder) {
        // Let IO and configuration cache exceptions surface to the top.
        if (error is IOException || error is ConfigurationCacheThrowable) {

import org.gradle.internal.service.scopes.Scope


@EventScope(Scope.BuildTree::class)
interface ProblemsListener {

    fun onProblem(problem: PropertyProblem)

    fun onError(trace: PropertyTrace, error: Exception, message: StructuredMessageBuilder)

    fun forIncompatibleTask(path: String): ProblemsListener

                try {
                    writeClass(update.javaClass)
                    write(update.key)
                    write(update.value)
                } catch (error: Exception) {
                    onError(error) {
                        text("failed to write system property ")
                        reference(keyString)
                    }
                }
            }
        }

 */
suspend fun WriteContext.writeNextProperty(name: String, value: Any?, kind: PropertyKind) {
    withPropertyTrace(kind, name) {
        try {
            write(value)
        } catch (error: Exception) {
            onError(error) {
                when {
                    value != null -> {
                        text("error writing value of type ")
                        reference(GeneratedSubclasses.unpackType(value))

    }

    override fun onProblem(problem: PropertyProblem) {
        currentProblemsListener.onProblem(problem)
    }

    override fun onError(error: Exception, message: StructuredMessageBuilder) {
        currentProblemsListener.onError(trace, error, message)
    }

    override suspend fun forIncompatibleType(path: String, action: suspend () -> Unit) {
        val previousListener = currentProblemsListener

        override var trace: PropertyTrace
            get() = undefined()
            set(_) {}

        override fun onProblem(problem: PropertyProblem): Unit =
            undefined()

        override fun onError(error: Exception, message: StructuredMessageBuilder) =
            undefined()

        override fun push(codec: Codec<Any?>): Unit =
            undefined()

        override fun push(owner: IsolateOwner): Unit =

        pluginRequests,
        buildscript,
        pluginManager,
        classLoaderScope
    )
}


private
fun <T> withCapturedOutputOnError(block: () -> T, onError: (ErrorWithCapturedOutput) -> T): T {
    val outCapture = ThreadLocalCapturePrintStream(System.out)
    val errCapture = ThreadLocalCapturePrintStream(System.err)
    return try {
        val previousOut = System.out

interface IsolateContext {

    val logger: Logger

    val isolate: Isolate

    val trace: PropertyTrace

    fun onProblem(problem: PropertyProblem)

    fun onError(error: Exception, message: StructuredMessageBuilder)
}


interface IsolateOwner {
    val delegate: Any
    fun <T> service(type: Class<T>): T
}

        return object : AbstractProblemsListener() {
            override fun onProblem(problem: PropertyProblem) {
                onProblem(problem, ProblemSeverity.Suppressed)
            }

            override fun onError(trace: PropertyTrace, error: Exception, message: StructuredMessageBuilder) {
                val failure = failureFactory.create(error)
                onProblem(PropertyProblem(trace, StructuredMessage.build(message), error, failure))