Class ClassNode

chasm/src/main/java/org/quiltmc/chasm/internal/tree/ClassNode.java:18–79

import org.quiltmc.chasm.lang.api.eval.Resolver;

public class ClassNode extends MapNode {
    private final ClassReader reader;

    public ClassNode(ClassReader reader, Context context, int index) {
        super(new LazyMap<>(getStaticEntries(reader),
                () -> getLazyEntries(reader, context, index)));
        this.reader = reader;

        PathMetadata root = new PathMetadata(null, index);
        PathInitializer.initialize(this, root);
    }

    // NOTE: Ensure parity with ChasmClassVisitor
    private static Map<String, Node> getStaticEntries(ClassReader reader) {
        Map<String, Node> entries = new LinkedHashMap<>();

        entries.put(NodeConstants.ACCESS, Ast.literal(reader.getAccess()));
        entries.put(NodeConstants.NAME, Ast.literal(reader.getClassName()));
        entries.put(NodeConstants.SUPER, Ast.nullableString(reader.getSuperName()));
        entries.put(NodeConstants.INTERFACES, Ast.list((Object[]) reader.getInterfaces()));

        return entries;
    }

    public Map<String, Node> getStaticEntries() {
        return ((LazyMap<String, Node>) getEntries()).getStaticEntries();
    }

    public Map<String, Node> getLazyEntries() {
        return ((LazyMap<String, Node>) getEntries()).getLazyEntries();
    }

    private static Map<String, Node> getLazyEntries(ClassReader reader, Context context,
                                                    int index) {
        ChasmClassVisitor visitor = new ChasmClassVisitor(context);
        reader.accept(visitor, 0);
        Map<String, Node> entries = visitor.getClassNode().getEntries();

        PathMetadata root = new PathMetadata(null, index);
        for (Map.Entry<String, Node> entry : entries.entrySet()) {
            PathMetadata path = new PathMetadata(root, entry.getKey());
            PathInitializer.initialize(entry.getValue(), path);
        }

        return entries;
    }

    public ClassReader getClassReader() {
        return reader;
    }

    @Override
    public void resolve(Resolver resolver) {
        // Class node can't contain references
    }

    @Override
    public Node evaluate(Evaluator evaluator) {