* by getName() is not unique in the hierarchy.
     *
     * @param element the element, cannot be null
     * @return the identity name of the element, never null
     */
    String getIdentityName(T element);

    /**
     * Returns the parent in this element's hierarchy.
     *
     * @param element the child element, cannot be null

     *
     * For example, this removes everything from the root which can't be kept after the current build finished.
     * This is anything which is not within a watchable hierarchy or in a cache directory.
     *
     * @return the snapshot hierarchy without snapshots which can't be kept till the next build.
     */
    @CheckReturnValue

        outputHierarchy.clear();
        destroyableHierarchy.clear();
    }

    /**
     * Create the input node access hierarchy.
     *
     * For performance reasons, we keep one input node access hierarchy per project,
     * so we only have a factory method here and this is used to create the hierarchy in {@link org.gradle.execution.ProjectExecutionServices}.
     */
    public InputNodeAccessHierarchy createInputHierarchy() {

        ImmutableSet<String> hierarchy = LazyToRealisedModuleComponentResolveMetadataHelper.constructHierarchy(configuration, configurationDefinitions);
        ImmutableList<ExcludeMetadata> excludes = configurationHelper.filterExcludes(hierarchy);

        ImmutableList<ModuleComponentArtifactMetadata> artifacts = configurationHelper.filterArtifacts(configurationName, hierarchy);

 *     <dd>The list of file system hierarchies that we've activated a file system probe for.
 *     We list every hierarchy here, even if there are ones nested inside others.
 *     See {@link FileWatcherProbeRegistry}.</dd>
 * </dl>
 */
public interface FileWatcherUpdater {
    /**
     * Registers a watchable hierarchy.
     *
     * @see FileWatcherRegistry#registerWatchableHierarchy(File, SnapshotHierarchy)
     */

    }

    interface Iface {}

    class Child extends Base implements Serializable, Iface {
        @Nullable
        Object doSomething() { null }
    }

    def "walking type hierarchy happens breadth-first"() {
        def visitor = Mock(Types.TypeVisitor)
        when:
        Types.walkTypeHierarchy(Child, [Object, GroovyObject], visitor)

     */
    Stream<FileSystemLocationSnapshot> roots();

    /**
     * Walks the whole hierarchy represented by this snapshot.
     *
     * The walk is depth first.
     */
    SnapshotVisitResult accept(FileSystemSnapshotHierarchyVisitor visitor);

    /**
     * Walks the whole hierarchy represented by this snapshot.
     *
     * The walk is depth first.
     */

            return null;
        }

        ImmutableSet<String> hierarchy = constructHierarchy(descriptorConfiguration);
        boolean transitive = descriptorConfiguration.isTransitive();
        boolean visible = descriptorConfiguration.isVisible();
        return createConfiguration(getId(), name, transitive, visible, hierarchy, variantMetadataRules);
    }

        ImmutableList<ModuleComponentArtifactMetadata> artifacts = configurationHelper.filterArtifacts(name, hierarchy);
        ImmutableList<ExcludeMetadata> excludesForConfiguration = configurationHelper.filterExcludes(hierarchy);

            ImmutableSet<String> hierarchy, ImmutableList<? extends ModuleComponentArtifactMetadata> artifacts,
            VariantMetadataRules componentMetadataRules,
            ImmutableList<ExcludeMetadata> excludes,
            ImmutableAttributes componentLevelAttributes,
            boolean externalVariant
    ) {