addEverythingListener(listener);
            return;
        }

        ModelNodeInternal ancestor = flattened.get(listener.getAncestor());
        if (ancestor != null) {
            Deque<ModelNodeInternal> queue = new ArrayDeque<ModelNodeInternal>();
            queue.add(ancestor);
            while (!queue.isEmpty()) {
                ModelNodeInternal parent = queue.removeFirst();

// tag::accessors[]
plugins {
    `java-library`
}

dependencies {                              // <1>
    api("junit:junit:4.13")
    implementation("junit:junit:4.13")
    testImplementation("junit:junit:4.13")
}

configurations {                            // <1>
    implementation {
        resolutionStrategy.failOnVersionConflict()
    }
}

sourceSets {                                // <2>

    makeAccessorOutputDirs(srcDir, binDir, outputPackage.path)

    // When building accessors for Settings, preserve semantics for existing custom accessors by
    // giving the generated accessors lower priority in Kotlin overload resolution.
    val useLowPriorityOverloadResolution = projectSchema.scriptTarget is Settings
    val moduleName = binDir?.name ?: "kotlin-dsl-accessors"
    val emittedClassNames =
        accessorsFor(projectSchema).map { accessor ->

            .createCacheBuilder("kotlin-dsl")
            .withDisplayName("kotlin-dsl"),
        fileAccessTimeJournal,
        2, // scripts and accessors caches sit below the root directory
        cacheConfigurations
    )

    val accessors = subWorkspace("accessors")

    val scripts = subWorkspace("scripts")

    override fun close() =
        kotlinDslWorkspace.close()

    private

    // the index doesn't cover classfiles from compiler output,
    // so the lowering fails.
    //
    // To solve the problem, we need to find all delegated properties with inline accessors
    // reachable from files that will be compiled, and include files these inline accessors
    // to the set of files that will be compiled (and do the same for these files recursively).

    }

    @Test
    fun `support should not depend on codegen`() {
        "..support.." shouldNotDependOn "..kotlin.dsl.codegen.."
    }

    @Test
    fun `accessors should not depend on execution`() {
        "..accessors.." shouldNotDependOn "..kotlin.dsl.execution.."
    }

    private
    infix fun String.shouldNotDependOn(thatPackage: String) {
        noClasses()

#
#Fri Jan 19 18:01:32 EST 2024
classes\ that\ are\ Gradle\ public\ API\ should\ have\ accessors\ with\ symmetrical\ @Nullable\ annotations=public-api-symmetrical-accessors-nullability.txt
classes\ that\ are\ Gradle\ public\ API\ should\ not\ have\ direct\ super-class\ or\ interface\ that\ are\ Gradle\ Internal\ API=public-api-not-extends-internal-types.txt

    ) {
        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();