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') {

    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 {

import org.gradle.internal.properties.bean.PropertyWalker;
import org.gradle.internal.reflect.validation.TypeValidationContext;

/**
 * A view of the properties of a task.
 *
 * This includes inputs, outputs, destroyables and local state properties.
 *
 * Once created, the view is immutable and registering additional or changing existing task properties will not be detected.
 *

                    ${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')}

        task.compareTo(_ as TaskInternal) >> { TaskInternal taskInternal ->
            return path.compareTo(taskInternal.identityPath)
        }
        task.outputs >> emptyTaskOutputs()
        task.destroyables >> emptyTaskDestroys()
        task.localState >> emptyTaskLocalState()
        task.inputs >> emptyTaskInputs()
        task.requiredServices >> emptyTaskRequiredServices()

        given:
        def outputDir = file("outDir")
        def outputFile = file("parent/outFile")
        def localStateFile = file("local-state/stateFile")
        def destroyableFile = file("destroyable/file.txt")

        when:
        step.execute(work, context)

        then:
        _ * work.visitOutputs(_ as File, _ as UnitOfWork.OutputVisitor) >> { File workspace, UnitOfWork.OutputVisitor visitor ->