dependency.accessRules.add(new AccessRule('0', 'id-accessible'))
                dependency.accessRules.add(new AccessRule('1', 'id-nonaccessible'))
                dependency.accessRules.add(new AccessRule('2', 'id-discouraged'))
                dependency.accessRules.add(new AccessRule('accessible', 'literal-accessible'))
                dependency.accessRules.add(new AccessRule('nonaccessible', 'literal-nonaccessible'))

    private
    fun targetTypesOf(accessorNameSpec: AccessorNameSpec): HashSet<TypeAccessibility.Accessible> =
        targetTypesByName.computeIfAbsent(accessorNameSpec) { hashSetOf() }
}


internal
fun extensionAccessor(spec: TypedAccessorSpec): String = spec.run {
    when (type) {
        is TypeAccessibility.Accessible -> accessibleExtensionAccessorFor(receiver.type.kotlinString, name, type.type.kotlinString)

                    // `implementation` dependencies are accessible
                    assert new com.fasterxml.jackson.databind.ObjectMapper().readTree("{\\\"hello\\\": \\\"test\\\"}").get("hello").asText().equals("test");

                    // `compileOnly` dependencies are accessible at compile-time
                    try {

        assertThat(
            projectSchema.extension("buildScan").type,
            equalTo(inaccessible(type, nonAvailable(type.kotlinString)))
        )
    }

    @Test
    fun `public type is represented as Accessible`() {

        val typeString = "existing.Type"

        val classPath = classPathWithPublicType(typeString)
        classLoaderFor(classPath).useToRun {
            val type = schemaTypeFor(typeString)

        this.privateDependentDelegate = privateDependentConsumer;
    }

    /**
     * Consume "accessible" dependents of a constant. Accessible dependents in this context
     * are dependents that have a constant calculated from constant from origin.
     *
     * Example of accessible dependent:
     * class A {
     *     public static final int CALCULATE_ACCESSIBLE_CONSTANT = CONSTANT;
     * }
     */

    fun `public generic type with primitive component type is accessible`() {

        val genericTypeWithPrimitiveComponent = SchemaType.of<PublicGenericType<String>>()
        assertThat(
            accessibilityFor(
                genericTypeWithPrimitiveComponent,
                classPath = jarClassPathWith(PublicGenericType::class)
            ),
            equalTo(accessible(genericTypeWithPrimitiveComponent))
        )
    }

	// ErrModelValueRequired model value required
	ErrModelValueRequired = errors.New("model value required")
	// ErrModelAccessibleFieldsRequired model accessible fields required
	ErrModelAccessibleFieldsRequired = errors.New("model accessible fields required")
	// ErrSubQueryRequired sub query required
	ErrSubQueryRequired = errors.New("sub query required")
	// ErrInvalidData unsupported data

import org.gradle.internal.serialization.Cached

import org.gradle.kotlin.dsl.accessors.ProjectSchemaProvider
import org.gradle.kotlin.dsl.accessors.TypedProjectSchema
import org.gradle.kotlin.dsl.accessors.accessible
import org.gradle.kotlin.dsl.accessors.accessorsFor
import org.gradle.kotlin.dsl.accessors.fragmentsFor

import org.gradle.work.DisableCachingByDefault
import javax.inject.Inject

            is ProjectComponentIdentifier -> if (fromComponent != rootComponent.id) {
                // Only track accessible dependencies from _transitive_ local dependencies
                // We should not include the root variant's dependencies in the locally accessible set
                locallyAccessible.add(to.owner)
            }
            is ModuleComponentIdentifier -> externallyAccessible.add(to.owner)

//go:build amd64 || arm64

package runtime

import _ "unsafe"

// As of Go 1.22, the symbols below are found to be pulled via
// linkname in the wild. We provide a push linkname here, to
// keep them accessible with pull linknames.
// This may change in the future. Please do not depend on them
// in new code.