outputs.file('foo')
                destroyables.register('bar')
            }
        """
        file('foo') << 'foo'
        file('bar') << 'bar'

        expect:
        2.times {
            fails 'a'
            failure.assertHasDescription('Task :a has both outputs and destroyables defined.  A task can define either outputs or destroyables, but not both.')
        }
    }

        given:
        withParallelThreads(2)
        buildFile << """
            def dir = rootProject.file("dir")

            aPing.destroyables.register dir

            bPing.outputs.file dir
        """

        expect:
        2.times {
            blockingServer.expectConcurrent(1, ":aPing", ":bPing")
            run ":aPing", ":bPing"

    from processTemplates
}
// end::inferred-task-dep-via-task[]


// tag::adhoc-destroyable-task[]
tasks.register('removeTempDir') {
    def tempDir = layout.projectDirectory.dir('tmpDir')
    destroyables.register(tempDir)
    doLast {
        tempDir.asFile.deleteDir()
    }
}
// end::adhoc-destroyable-task[]

tasks.named('build') {

    }

    private
    suspend fun WriteContext.writeDestroyablesOf(task: TaskInternal) {
        val destroyables = (task.destroyables as TaskDestroyablesInternal).registeredFiles
        if (destroyables.isEmpty) {
            writeBoolean(false)
        } else {
            writeBoolean(true)
            write(destroyables)
        }
    }

    private
    suspend fun ReadContext.readDestroyablesOf(task: TaskInternal) {

    from(processTemplates)
}
// end::inferred-task-dep-via-task[]


// tag::adhoc-destroyable-task[]
tasks.register("removeTempDir") {
    val tmpDir = layout.projectDirectory.dir("tmpDir")
    destroyables.register(tmpDir)
    doLast {
        tmpDir.asFile.deleteRecursively()
    }
}
// end::adhoc-destroyable-task[]

tasks.build {

            </tr>
            <tr>
                <td>outputs</td>
            </tr>
            <tr>
                <td>localState</td>
            </tr>
            <tr>
                <td>destroyables</td>
            </tr>
            <tr>
                <td>temporaryDir</td>
            </tr>
            <tr>
                <td>taskDependencies</td>
            </tr>
            <tr>

            visitor.visitDestroyableProperty(registeredPath);
        }
    }

    @Override
    public FileCollection getRegisteredFiles() {
        return fileCollectionFactory.resolving("destroyables", registeredPaths);
    }

 * Before task execution ({@link org.gradle.api.internal.tasks.execution.ExecuteTaskBuildOperationType}),
 * the mutations of the task need to be resolved. The mutations of a task are the locations it may modify,
 * e.g. its outputs, destroyables and local state. In order to resolve the mutations, the task input and output
 * properties are detected as well. Since Gradle 7.5, resolving of the mutations happens in a separate node
 * in the execution graph.
 *

import org.gradle.internal.fingerprint.FileNormalizer;
import org.gradle.internal.fingerprint.LineEndingSensitivity;

import javax.annotation.Nullable;

/**
 * Visits properties of beans which are inputs, outputs, destroyables, local state, service references or software types.
 */
public interface PropertyVisitor {

                    ${produces.collect { 'outputs.file file(' + quote(it) + ')' }.join('\n\t\t\t\t')}
                    ${destroys.collect { 'destroyables.register file(' + quote(it) + ')' }.join('\n\t\t\t\t')}
                    ${localState.collect { 'localState.register file(' + quote(it) + ')' }.join('\n\t\t\t\t')}