Java Node.accept方法代码示例

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
/**
 * When we eliminate dead code, we must preserve var declarations as they are scoped to the whole
 * function. This method gathers var nodes from code passed to it, removing their initializers.
 *
 * @param deadCodeRoot the root node of eliminated dead code
 * @param statements a list that will be receiving the var nodes from the dead code, with their
 * initializers removed.
 */
static void extractVarNodesFromDeadCode(final Node deadCodeRoot, final List<Statement> statements) {
    deadCodeRoot.accept(new SimpleNodeVisitor() {
        @Override
        public boolean enterVarNode(final VarNode varNode) {
            statements.add(varNode.setInit(null));
            return false;
        }

        @Override
        public boolean enterFunctionNode(final FunctionNode functionNode) {
            // Don't descend into nested functions
            return false;
        }
    });
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
@Override
public boolean enterIfNode(final IfNode ifNode) {
    enterDefault(ifNode);

    type("IfStatement");
    comma();

    property("test");
    ifNode.getTest().accept(this);
    comma();

    property("consequent");
    ifNode.getPass().accept(this);
    final Node elsePart = ifNode.getFail();
    comma();

    property("alternate");
    if (elsePart != null) {
        elsePart.accept(this);
    } else {
        nullValue();
    }

    return leave();
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
@Override
public boolean enterReturnNode(final ReturnNode returnNode) {
    enterDefault(returnNode);

    type("ReturnStatement");
    comma();

    final Node arg = returnNode.getExpression();
    property("argument");
    if (arg != null) {
        arg.accept(this);
    } else {
        nullValue();
    }

    return leave();
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
private void array(final String name, final List<? extends Node> nodes) {
    // The size, idx comparison is just to avoid trailing comma..
    final int size = nodes.size();
    int idx = 0;
    arrayStart(name);
    for (final Node node : nodes) {
        if (node != null) {
            node.accept(this);
        } else {
            nullValue();
        }
        if (idx != (size - 1)) {
            comma();
        }
        idx++;
    }
    arrayEnd();
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
@Override
public boolean enterCatchNode(final CatchNode catchNode) {
    enterDefault(catchNode);

    type("CatchClause");
    comma();

    property("param");
    catchNode.getException().accept(this);
    comma();

    final Node guard = catchNode.getExceptionCondition();
    if (guard != null) {
        property("guard");
        guard.accept(this);
        comma();
    }

    property("body");
    catchNode.getBody().accept(this);

    return leave();
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
private boolean emitProgram(final FunctionNode functionNode) {
    enterDefault(functionNode);
    type("Program");
    comma();

    // body consists of nested functions and statements
    final List<Statement> stats = functionNode.getBody().getStatements();
    final int size = stats.size();
    int idx = 0;
    arrayStart("body");

    for (final Node stat : stats) {
        stat.accept(this);
        if (idx != (size - 1)) {
            comma();
        }
        idx++;
    }
    arrayEnd();

    return leave();
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
@Override
public boolean enterVarNode(final VarNode varNode) {
    sb.append(varNode.isConst() ? "const " : varNode.isLet() ? "let " : "var ");
    varNode.getName().toString(sb, printTypes);
    printLocalVariableConversion(varNode.getName());
    final Node init = varNode.getInit();
    if (init != null) {
        sb.append(" = ");
        init.accept(this);
    }

    return false;
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
@SuppressWarnings("rawtypes")
@Override
public boolean enterLiteralNode(final LiteralNode literalNode) {
    weight += LITERAL_WEIGHT;

    if (literalNode instanceof ArrayLiteralNode) {
        final ArrayLiteralNode arrayLiteralNode = (ArrayLiteralNode)literalNode;
        final Node[]           value            = arrayLiteralNode.getValue();
        final int[]            postsets         = arrayLiteralNode.getPostsets();
        final List<Splittable.SplitRange>  units            = arrayLiteralNode.getSplitRanges();

        if (units == null) {
            for (final int postset : postsets) {
                weight += AASTORE_WEIGHT;
                final Node element = value[postset];

                if (element != null) {
                    element.accept(this);
                }
            }
        }

        return false;
    }

    return true;
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
@Override
public boolean enterVarNode(final VarNode varNode) {
    sb.append("var ");
    varNode.getName().toString(sb, printTypes);
    printLocalVariableConversion(varNode.getName());
    final Node init = varNode.getInit();
    if (init != null) {
        sb.append(" = ");
        init.accept(this);
    }

    return false;
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
private static Node ensureUniqueNamesIn(final Node node) {
    return node.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
        @Override
        public Node leaveFunctionNode(final FunctionNode functionNode) {
            final String name = functionNode.getName();
            return functionNode.setName(lc, lc.getCurrentFunction().uniqueName(name));
        }

        @Override
        public Node leaveDefault(final Node labelledNode) {
            return labelledNode.ensureUniqueLabels(lc);
        }
    });
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
@SuppressWarnings("rawtypes")
@Override
public boolean enterLiteralNode(final LiteralNode literalNode) {
    weight += LITERAL_WEIGHT;

    if (literalNode instanceof ArrayLiteralNode) {
        final ArrayLiteralNode arrayLiteralNode = (ArrayLiteralNode)literalNode;
        final Node[]           value            = arrayLiteralNode.getValue();
        final int[]            postsets         = arrayLiteralNode.getPostsets();
        final List<ArrayUnit>  units            = arrayLiteralNode.getUnits();

        if (units == null) {
            for (final int postset : postsets) {
                weight += AASTORE_WEIGHT;
                final Node element = value[postset];

                if (element != null) {
                    element.accept(this);
                }
            }
        }

        return false;
    }

    return true;
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
static long weigh(final Node node, final Map<Node, Long> weightCache) {
    final WeighNodes weighNodes = new WeighNodes(node instanceof FunctionNode ? (FunctionNode)node : null, weightCache);
    node.accept(weighNodes);
    return weighNodes.weight;
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
@Override
public boolean enterPropertyNode(final PropertyNode propertyNode) {
    final Node key = propertyNode.getKey();

    final Node value = propertyNode.getValue();
    if (value != null) {
        objectStart();
        location(propertyNode);

        property("key");
        key.accept(this);
        comma();

        property("value");
        value.accept(this);
        comma();

        property("kind", "init");

        objectEnd();
    } else {
        // getter
        final Node getter = propertyNode.getGetter();
        if (getter != null) {
            objectStart();
            location(propertyNode);

            property("key");
            key.accept(this);
            comma();

            property("value");
            getter.accept(this);
            comma();

            property("kind", "get");

            objectEnd();
        }

        // setter
        final Node setter = propertyNode.getSetter();
        if (setter != null) {
            if (getter != null) {
                comma();
            }
            objectStart();
            location(propertyNode);

            property("key");
            key.accept(this);
            comma();

            property("value");
            setter.accept(this);
            comma();

            property("kind", "set");

            objectEnd();
        }
    }

    return false;
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
@Override
public boolean enterVarNode(final VarNode varNode) {
    final Node init = varNode.getInit();
    if (init instanceof FunctionNode && ((FunctionNode)init).isDeclared()) {
        // function declaration - don't emit VariableDeclaration instead
        // just emit FunctionDeclaration using 'init' Node.
        init.accept(this);
        return false;
    }

    enterDefault(varNode);

    type("VariableDeclaration");
    comma();

    arrayStart("declarations");

    // VariableDeclarator
    objectStart();
    location(varNode.getName());

    type("VariableDeclarator");
    comma();

    property("id");
    varNode.getName().accept(this);
    comma();

    property("init");
    if (init != null) {
        init.accept(this);
    } else {
        nullValue();
    }

    // VariableDeclarator
    objectEnd();

    // declarations
    arrayEnd();

    return leave();
}
 

import jdk.nashorn.internal.ir.Node; //导入方法依赖的package包/类
private void visit(final Node root) {
    root.accept(this);
}