import static org.gradle.internal.snapshot.impl.SerializedLambdaQueries.serializedLambdaFor;

/**
 * Identifies a type in a classloader hierarchy. The type is identified by its name,
 * the classloader hierarchy by its hash code.
 */
public abstract class ImplementationSnapshot implements ValueSnapshot {

    protected final String classIdentifier;

     *
     * <p>There are two cases where this might be true: Gradle was invoked from a directory where there is no build script and no settings script in the directory hierarchy,
     * or Gradle was invoked from a directory where there is a settings script in the directory hierarchy but the directory is not a project directory for any project defined
     * in that settings script.</p>
     */
    public boolean isBuildDefinitionMissing() {

    }

    def "task names must not contain forbidden characters"() {
        given:
        buildFile << "task 'this/is/a/hierarchy'"

        when:
        fails 'this/is/a/hierarchy'

        then:
        assertFailureContainsForbiddenCharacterMessage('task name',"this/is/a/hierarchy")
    }

    def "configuration names must not contain forbidden characters"() {
        given:

                collector.add(dependencyDescriptor);
            }
        });
    }

    /**
     * We write types hierarchy and metadata with dependencies as a separate file, since
     * type hierarchy is an input to {@link MergeInstrumentationAnalysisTransform}.
     */

    @Nullable
    File getDestinationDir();

    /**
     * Listener triggered when a spec is added to the hierarchy.
     */
    interface CopySpecListener {
        void childSpecAdded(CopySpecAddress path, CopySpecInternal spec);
    }

    /**
     * A visitor to traverse the spec hierarchy.
     */
    interface CopySpecVisitor {
        void visit(CopySpecAddress address, CopySpecInternal spec);
    }

//   - Names may contain at most one ':'. In the counter "foo:bar", we refer to
//     "foo" as the "chart name" and "bar" as the "bucket name".
//
//   - The '/' character should partition counter names into a hierarchy. The
//     root of this hierarchy should identify the logical entity that "owns"
//     the counter. This could be an application, such as "gopls" in the case
//     of "gopls/client:vscode", or a shared library, such as "crash" in the

     */
    Optional<HashCode> readRegularFileContentHash(String location);

    /**
     * Reads the hierarchy of files at the given location.
     */
    FileSystemLocationSnapshot read(String location);

    /**
     * Visits the hierarchy of files which match the filter at the given location.
     *
     * Returns empty {@link Optional} if filter doesn't match anything.
     */

import org.gradle.internal.file.impl.DefaultFileMetadata
import org.gradle.internal.hash.TestHashCodes

class DirectorySnapshotTest extends AbstractFileSystemLocationSnapshotTest {
    def "snapshot hierarchy accessed directly is relocated"() {
        def testDirectory = temporaryFolder.createDir("test")
        def sourceDir = testDirectory.createDir("source-directory")
        def childDir = sourceDir.createDir("child")

 */
public interface TypeMetadataWalker<T, V extends TypeMetadataWalker.TypeMetadataVisitor<T>> {

    /**
     * A factory method for a walker that can visit the property hierarchy of an instance.
     *
     * When visiting a nested property, child properties are discovered using the type of the
     * return property value. This can be a more specific type than the return type of the property's

        @Override String someOverloadedMethod(int param)
        @Override String someOverriddenCovariantMethod(Object param)
    }

    def "gets overridden methods from type hierarchy"() {
        expect:
        def overridden = ModelSchemaUtils.getCandidateMethods(SubTypeWithOverloadedMethods).overriddenMethodsNamed("someOverloadedMethod")
        overridden.size() == 2