when (this) {
            is TypeAccessibility.Accessible ->
                TypedAccessorSpec(this, accessorNameSpec(schemaEntry.name), schemaEntry.type)
            is TypeAccessibility.Inaccessible ->
                null
        }
    }


private
fun documentInaccessibilityReasons(name: AccessorNameSpec, typeAccess: TypeAccessibility.Inaccessible): String =

    fun `non existing type is represented as Inaccessible because NonAvailable`() {

        val type = SchemaType.of<NonExistingType>()

        val projectSchema = availableProjectSchemaFor(
            schemaWithExtensions("buildScan" to type),
            ClassPath.EMPTY
        )

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

	// inaccessible   x.foo   !=    foo    cannot refer to unexported field foo
	// missing        x.foo   !=    foO    type X has no field or method foo

	const (
		ok           = iota
		missing      // no object found
		misspelled   // found object with different spelling
		unexported   // found object with name differing only in first letter

    fun `internal Kotlin type is inaccessible because NonPublic`() {

        val internalType = SchemaType.of<InternalType>()
        assertThat(
            accessibilityFor(
                internalType,
                classPath = jarClassPathWith(InternalType::class)
            ),
            equalTo(inaccessible(internalType, InaccessibilityReason.NonPublic(internalType.kotlinString)))
        )
    }

    @Test

	// inaccessible   x.foo   !=    foo    cannot refer to unexported field foo
	// missing        x.foo   !=    foO    type X has no field or method foo

	const (
		ok           = iota
		missing      // no object found
		misspelled   // found object with different spelling
		unexported   // found object with name differing only in first letter

    InaccessibilityReason.TypeErasure(type)


internal
fun accessible(type: SchemaType): TypeAccessibility =
    TypeAccessibility.Accessible(type)


internal
fun inaccessible(type: SchemaType, vararg reasons: InaccessibilityReason) =
    inaccessible(type, reasons.toList())


internal
fun inaccessible(type: SchemaType, reasons: List<InaccessibilityReason>): TypeAccessibility =

 * @since 3.0
 */
public interface AccessRule {

    /**
     * Returns the encoded type of the access rule. The meaning of the values:
     * <ul>
     *     <li>0: the rule defines accessible paths</li>
     *     <li>1: the rule defines inaccessible paths</li>
     *     <li>2: the rule defines discouraged paths</li>
     * </ul>
     *
     * @return The type of this access rule.
     */
    int getKind();

    /**

    public static final String REGISTRY_ENTRY_UNEXPECTEDLY_LOST = "after the daemon was no longer found in the daemon registry";
    public static final String REGISTRY_BECAME_INACCESSIBLE = "after the daemon registry became inaccessible";

    private final Daemon daemon;

    public DaemonRegistryUnavailableExpirationStrategy(Daemon daemon) {
        this.daemon = daemon;
    }

    @Override

    if (!isValid()) {
        throw KaInvalidLifetimeOwnerAccessException("Access to invalid $this: ${getInvalidationReason()}")
    }
    if (!isAccessible()) {
        throw KaInaccessibleLifetimeOwnerAccessException("$this is inaccessible: ${getInaccessibilityReason()}")
    }
}

public abstract class KaIllegalLifetimeOwnerAccessException : IllegalStateException()

			true +
			uint +
			uint8 +
			uint16 +
			uint32 +
			uint64 +
			uintptr +
			iota
	if n != NUM*(NUM-1)/2 {
		fmt.Println("BUG: wrong n", n, NUM*(NUM-1)/2)
		runtime.Breakpoint() // panic is inaccessible
	}
}

const (
	// cannot use iota here, because iota = 38 below
	append     = 1
	bool       = 2
	byte       = 3
	complex    = 4
	complex64  = 5
	complex128 = 6
	cap        = 7