//
	// The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the
	// object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible.
	//
	// Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL
	// expressions. This includes:

    /**
     * Populate the Map of direct hits. These
     * are taken from all the public methods
     * that our class provides.
     */
    private void populateMethodCache() {
        // get all publicly accessible methods
        Method[] methods = getAccessibleMethods(clazz);

        // map and cache them
        for (Method method : methods) {
            // now get the 'public method', the method declared by a

        "String"     | "\"hello\""   | "+ \"world\""
        "int"        | "1"           | "+ 2"
        "boolean"    | "true"        | "& false"
    }

    def "collects constants from accessible static fields as accessible dependents"() {
        given:
        String clazz = """
class A {
    static final int STATIC_FINAL_FIELD = Constant1.CONSTANT1;
}
"""

 *
 * @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.
     */

			case _AT_HWCAP:
				hwCap = val
			case _AT_HWCAP2:
				hwCap2 = val
			}
		}
		return nil
	}

	buf, err := os.ReadFile(procAuxv)
	if err != nil {
		// e.g. on android /proc/self/auxv is not accessible, so silently
		// ignore the error and leave Initialized = false. On some
		// architectures (e.g. arm64) doinit() implements a fallback
		// readout and will set Initialized = true again.
		return err
	}

import org.jetbrains.kotlin.name.Name

/**
 * [FirNonStaticMembersScope] includes non-static callables and inner classes.
 *
 * Inner classes are included because they are accessible from a value of the outer class. For example:
 *
 * ```
 * class Outer {
 *     inner class Inner
 * }
 *
 * fun foo() {
 *     val outer = Outer()
 *     outer.Inner()
 * }
 * ```
 *

        when:
        Field field = groovy.ant.AntBuilder.class.getDeclaredField('collectorTarget')
        field.accessible = true
        Target target = field.get(ant)
        field = target.class.getDeclaredField('children')
        field.accessible = true
        List children = field.get(target)

        then:
        children.isEmpty()
    }

        if (currentToken != this) return "Using a lifetime owner from an old `analyze` context."

        error("Cannot get an inaccessibility reason for a lifetime token when it's accessible.")
    }
}

public object KotlinReadActionConfinementLifetimeTokenFactory : KaLifetimeTokenFactory() {
    override val identifier: KClass<out KaLifetimeToken> = KotlinReadActionConfinementLifetimeToken::class

     *
     * {@link Optional#empty()} if no information is available.
     */
    Optional<MetadataSnapshot> getSnapshot();

    boolean hasDescendants();

    /**
     * Returns all the snapshot roots accessible from the node.
     */
    Stream<FileSystemLocationSnapshot> rootSnapshots();

    /*
     * Gets a snapshot from the current node with relative path filePath.substring(offset).
     *

     */
    void visitFailures(Consumer<Throwable> visitor);

    /**
     * Returns all failures to resolve a dependency.
     * These failures are also accessible via the resolution result.
     */
    Set<UnresolvedDependency> getUnresolvedDependencies();

    /**
     * Returns an optional failure describing an error that occurred during resolution.