) {
        this.delegate = CacheBasedImmutableWorkspaceProvider.createWorkspaceProvider(
            cacheBuilderFactory
                .createCacheBuilder("dependencies-accessors")
                .withDisplayName("dependencies-accessors"),
            fileAccessTimeJournal,
            cacheConfigurations
        );
    }

    @Override
    public ImmutableWorkspace getWorkspace(String path) {

    // not necessarily planned to be implemented, but capturing the existing behavior
    @ToBeImplemented
    def "included builds participate in type-safe accessors generation"() {
        settingsFile << """
            rootProject.name = 'test'

            includeBuild 'other'
        """
        file('other/settings.gradle') << """
            rootProject.name = 'other'

                throw new InvalidUserDataException("Cannot convert a version catalog entry '" + notationAsString + "' to an object of type ModuleVersionSelector. " +
                    "Only dependency accessors are supported but not plugin, bundle or version accessors for '" + caller + "'.");
            }
            MinimalExternalModuleDependency dependency = (MinimalExternalModuleDependency) notation.get();

import org.gradle.kotlin.dsl.support.bytecode.newClassTypeOf
import java.io.File
import javax.inject.Inject


/**
 * Produces an [AccessorsClassPath] with type-safe accessors for Stage 1 blocks such as
 * `buildscript {}` and `plugins {}`.
 *
 * Generates accessors for:
 * - dependency version catalogs found in this build,
 * - plugin spec builders for all plugin ids found in the `buildSrc` classpath.
 */

        .put("tar.large", new CommonsTarPacker(64))
        .put("tar.gz", new GzipPacker(new CommonsTarPacker(4)))
        .put("zip", new ZipPacker(4))
        .build();

    private static final Map<String, DataAccessor> ACCESSORS = ImmutableMap.<String, DataAccessor>builder()
        .put("direct", new DirectFileFileAccessor(DIRECTORY_PROVIDER))
        .put("buffered", new BufferedFileAccessor(8, DIRECTORY_PROVIDER))

        @Override
        public void visitExact(InputDeclaration value) {
            foundInput();
        }

        @Override
        public void visitAncestor(InputDeclaration ancestor, VfsRelativePath pathToVisitedLocation) {
            if (ancestor.contains(pathToVisitedLocation)) {
                foundInput();
            }
        }

        @Override

package org.gradle.kotlin.dsl

import org.gradle.api.Incubating
import org.gradle.api.toolchain.management.ToolchainManagement
import org.gradle.jvm.toolchain.JvmToolchainManagement


/**
 * Provides statically defined accessors for configuring the "jvm" block in "toolchainManagement".
 * The "jvm-toolchain-management" plugin needs to be applied in order for these extensions to work.
 *
 * @since 7.6
 */
@Incubating

        0 * listener.onDiscovered(_)
    }

    def "notifies listener of node with root ancestor"() {
        def listener = allAcceptingListener()

        def a = node("a")
        def b = node("a.b")
        def c = node("a.b.c")
        def d = node("d")

        given:
        listener.ancestor >> ModelPath.ROOT

        when:
        graph.add(a)
        graph.add(b)

    /**
     * Returns the shared component metadata handler
     */
    ComponentMetadataHandler getComponents();

    /**
     * Configures the version catalogs which will be used to generate type safe accessors for dependencies.
     * @param spec the spec to configure the dependencies
     *
     * @since 7.0
     */
    void versionCatalogs(Action<? super MutableVersionCatalogContainer> spec);

    /**

package org.gradle.kotlin.dsl.provider.plugins

import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.internal.project.ProjectInternal
import org.gradle.kotlin.dsl.accessors.tasks.PrintAccessors
import org.gradle.kotlin.dsl.accessors.warnAboutDiscontinuedJsonProjectSchema
import org.gradle.kotlin.dsl.provider.KotlinScriptBasePluginsApplicator