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

@TargetGradleVersion(">=8.8")
@Flaky(because = "https://github.com/gradle/gradle-private/issues/3714")
class KotlinSettingsScriptModelCrossVersionSpec extends AbstractKotlinScriptModelCrossVersionTest {

    def "settings script has type-safe accessors on the classpath"() {
        given:
        withDefaultSettingsIn("included")
        withBuildScriptIn("included", """
            plugins { `kotlin-dsl` }
            $repositoriesBlock
        """)

import kotlinx.metadata.jvm.moduleName
import kotlinx.metadata.jvm.signature
import kotlinx.metadata.jvm.syntheticMethodForAnnotations
import org.gradle.kotlin.dsl.accessors.ExtensionSpec
import org.gradle.kotlin.dsl.accessors.accessorDescriptorFor
import org.gradle.kotlin.dsl.accessors.nonInlineGetterFlags
import org.gradle.kotlin.dsl.support.uppercaseFirstChar
import org.jetbrains.org.objectweb.asm.ClassVisitor

        def ex = thrown(InvalidUserDataException)
        ex.message.contains "Cannot convert a version catalog entry 'pluginId:1.0' to an object of type ModuleVersionSelector. Only dependency accessors are supported but not plugin, bundle or version accessors for 'force()'"
    }

    def "reports unsupported provider convertible type"() {
        given:
        def providerConvertible = Stub(ProviderConvertible.class)