private void nonEmptyPredecessors(BuildStep step, Set<BuildStep> preds, Set<BuildStep> visited) {
        if (visited.add(step)) {
            step.predecessors.forEach(ch -> {
                if (ch.executions().findAny().isPresent()) {
                    preds.add(ch);
                } else {
                    nonEmptyPredecessors(ch, preds, visited);
                }
            });
        }
    }

    # since we're creating a new limiter for each call, any non-zero limit
    # works (1 is arbitrary)
    exit_limiter = CapacityLimiter(1)
    try:
        yield await run_in_threadpool(cm.__enter__)
    except Exception as e:
        ok = bool(
            await anyio.to_thread.run_sync(
                cm.__exit__, type(e), e, e.__traceback__, limiter=exit_limiter
            )
        )
        if not ok:

 *   }
 * }.visit(type);
 * }
 *
 * <p>One {@code Type} is visited at most once. The second time the same type is visited, it's
 * ignored by {@link #visit}. This avoids infinite recursion caused by recursive type bounds.
 *
 * <p>This class is not thread safe.
 *
 * @author Ben Yu
 */
abstract class TypeVisitor {

  private final Set<Type> visited = new HashSet<>();

  /**

    fun visitTree(
        classDetails: ClassDetails,
        classesDir: File,
        jarOutputStream: JarOutputStream,
        visited: MutableSet<ClassDetails>
    ) {

        if (!visited.add(classDetails)) {
            return
        }
        if (classDetails.visited) {
            val fileName = classDetails.outputClassFilename
            val classFile = classesDir.resolve(fileName)

    TypeVisitor visitor = new BaseTypeVisitor();
    try {
      visitor.visit(type);
      fail("Type not visited");
    } catch (UnsupportedOperationException expected) {
    }
    try {
      visitor.visit(new Type[] {type});
      fail("Type not visited");
    } catch (UnsupportedOperationException expected) {
    }
  }

  private static class BaseTypeVisitor extends TypeVisitor {

        return isSuccessorOf(new HashSet<>(), step);
    }

    private boolean isSuccessorOf(Set<BuildStep> visited, BuildStep step) {
        if (this == step) {
            return true;
        } else if (visited.add(this)) {
            return this.predecessors.stream().anyMatch(n -> n.isSuccessorOf(visited, step));
        } else {
            return false;
        }
    }

    public void skip() {

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

class Graph {
    private enum DfsState {
        VISITING,
        VISITED
    }

    final Map<String, Vertex> vertices = new LinkedHashMap<>();

    public Vertex getVertex(String id) {
        return vertices.get(id);
    }

    public Collection<Vertex> getVertices() {

    }

    public void analyzePom(Model model) {
        totalPoms++;
        Set<Object> visited = new HashSet<>();
        processModelNode(model, "/project", "project", visited);
    }

    private void processModelNode(Object node, String currentPath, String elementName, Set<Object> visited) {
        if (node == null || !visited.add(node)) {
            return;
        }

        Class<?> clazz = node.getClass();

32CD          ; mapped                 ; 0065 0072 0067 #4.0  SQUARE ERG
32CE          ; mapped                 ; 0065 0076     # 4.0  SQUARE EV
32CF          ; mapped                 ; 006C 0074 0064 #4.0  LIMITED LIABILITY SIGN
32D0          ; mapped                 ; 30A2          # 1.1  CIRCLED KATAKANA A
32D1          ; mapped                 ; 30A4          # 1.1  CIRCLED KATAKANA I

        ClasspathContainer cpc;

        List<MetadataGraphVertex> visited;

        // -----------------------------------------------------------------------
        protected ClasspathGraphVisitor(MetadataGraph cleanGraph, ClasspathContainer cpc) {
            this.cpc = cpc;
            this.graph = cleanGraph;

            visited = new ArrayList<>(cleanGraph.getVertices().size());
        }