return []
        }
        List<String> prefixes = new ArrayList<>()
        def node = set.rootNode
        def unpackedNode = (node.getSnapshot()
            .filter { it instanceof FileSystemLocationSnapshot }
            .orElse(node))
        if (unpackedNode instanceof DirectorySnapshot) {
            def children = unpackedNode.children
            children.forEach { child ->

                // Flatten adocs into a single directory
                sub.eachFile(fcd -> fcd.setRelativePath(RelativePath.parse(true, fcd.getName())));
            });

            // From the snippets and the samples, filter out files generated if the build contained was ever executed
            task.from(extension.getUserManual().getSnippets(), sub -> {
                sub.into("snippets");
                sub.exclude("**/.gradle/**");

    generatePluginAdaptersFor(scriptPlugins, kotlinSourceDirectorySet)
}


private
fun SourceDirectorySet.collectScriptPluginFiles(): Set<File> =
    matching { it.include("**/*.gradle.kts") }
        .filter { it.isFile }
        .files


private
val SourceSet.kotlin: SourceDirectorySet
    get() = extensions.getByName("kotlin") as SourceDirectorySet


private

    private
    fun compiledScriptClassFile(plugin: PrecompiledScriptPlugin) =
        plugin.compiledScriptTypeName.replace('.', '/') + ".class"

    private
    fun selectProjectScriptPlugins() = plugins.filter { it.scriptType == KotlinScriptType.PROJECT }

    private
    fun createPluginsClassLoader(): ClassLoader =
        URLClassLoader(
            compiledPluginsClassPath().asURLArray,

        visited[knownDir.absolutePath].is(knownDirSnapshot)
        visited[previouslyUnknownFile.absolutePath] == null
    }

    def "should reuse existing file and directory snapshots when using a filter"() {
        given:
        def rootDir = tmpDir.createDir("root")
        def knownDir = rootDir.file("known").createDir()
        def knownTextFile = rootDir.file("known/known.txt").createFile()

         * call: it may be already completely or partially modified to reflect the result of the operation.
         *
         * @param key the key used by the caller to access the property
         * @param value the value observed by the caller or {@code null} if there is no value for the given key
         */
        void onAccess(Object key, @Nullable Object value);

        /**

     */
    private void moveMethodFiltersToScenarios() {
        DefaultTestFilter filter = getFilter() as DefaultTestFilter
        List<String> scenarios = []
        Set<String> classOnlyFilters = new LinkedHashSet<>()
        filter.getCommandLineIncludePatterns().each { includePattern ->
            def lastDot = includePattern.lastIndexOf(".")
            if (lastDot == -1) {

            )
            withProblemsWithStackTraceCount(0)
        }

        and:
        outputContains("this.reference = JavaRecord[value=null, filler=101]")
        outputContains("bean.reference = JavaRecord[value=null, filler=202]")

        when:
        configurationCacheRunLenient "broken"

        then:
        problems.assertResultHasProblems(result) {

        then:
        unpackedValue == 24
        1 * sideEffect.execute(24)
        0 * _

        where:
        description       | wrap
        "Provider.filter" | { p -> p.filter({ true }) }
        "Provider.map"    | { p -> p.map { it } }
    }

    def "does not run the side effect when changing provider is filtered with #description and spec is not satisfied"() {
        given:

import org.gradle.kotlin.dsl.resolver.SourceDistributionResolver
import org.gradle.kotlin.dsl.resolver.SourcePathProvider
import org.gradle.kotlin.dsl.support.ImplicitImports
import org.gradle.kotlin.dsl.support.filter
import org.gradle.kotlin.dsl.support.isGradleKotlinDslJar
import org.gradle.kotlin.dsl.support.serviceOf
import org.gradle.kotlin.dsl.tooling.builders.AbstractKotlinDslScriptsModelBuilder