import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
private Node leaveTYPEOF(final UnaryNode unaryNode) {
    final Expression rhs = unaryNode.getExpression();

    final List<Expression> args = new ArrayList<>();
    if (rhs instanceof IdentNode && !isParamOrVar((IdentNode)rhs)) {
        args.add(compilerConstantIdentifier(SCOPE));
        args.add((Expression)LiteralNode.newInstance(rhs, ((IdentNode)rhs).getName()).accept(this)); //null
    } else {
        args.add(rhs);
        args.add((Expression)LiteralNode.newInstance(unaryNode).accept(this)); //null, do not reuse token of identifier rhs, it can be e.g. 'this'
    }

    final Node runtimeNode = new RuntimeNode(unaryNode, Request.TYPEOF, args).accept(this);

    end(unaryNode);

    return runtimeNode;
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
private Node leaveTYPEOF(final UnaryNode unaryNode) {
    final Expression rhs = unaryNode.getExpression();

    final List<Expression> args = new ArrayList<>();
    if (rhs instanceof IdentNode && !isParamOrVar((IdentNode)rhs)) {
        args.add(compilerConstantIdentifier(SCOPE));
        args.add(LiteralNode.newInstance(rhs, ((IdentNode)rhs).getName())); //null
    } else {
        args.add(rhs);
        args.add(LiteralNode.newInstance(unaryNode)); //null, do not reuse token of identifier rhs, it can be e.g. 'this'
    }

    final Node runtimeNode = new RuntimeNode(unaryNode, Request.TYPEOF, args);

    end(unaryNode);

    return runtimeNode;
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
/**
 * Add is a special binary, as it works not only on arithmetic, but for
 * strings etc as well.
 */
@Override
public Expression leaveADD(final BinaryNode binaryNode) {
    final Expression lhs = binaryNode.lhs();
    final Expression rhs = binaryNode.rhs();

    final Type type = binaryNode.getType();

    if (type.isObject()) {
        if (!isAddString(binaryNode)) {
            return new RuntimeNode(binaryNode, Request.ADD);
        }
    }

    return binaryNode.setLHS(convert(lhs, type)).setRHS(convert(rhs, type));
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
private static Type firstTypeGuessForObject(final Request request) {
    switch (request) {
    case ADD:
        return INT;
    default:
        return BOOLEAN;
    }
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
@Override
public Node leaveRuntimeNode(final RuntimeNode runtimeNode) {
    final Request request = runtimeNode.getRequest();
    final boolean isEqStrict = request == Request.EQ_STRICT;
    if(isEqStrict || request == Request.NE_STRICT) {
        return createIsUndefined(runtimeNode, runtimeNode.getArgs().get(0), runtimeNode.getArgs().get(1),
                isEqStrict ? Request.IS_UNDEFINED : Request.IS_NOT_UNDEFINED);
    }
    return runtimeNode;
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
private void loadRuntimeNode(final RuntimeNode runtimeNode) {
    final List<Expression> args = new ArrayList<>(runtimeNode.getArgs());
    if (nullCheck(runtimeNode, args)) {
       return;
    } else if(undefinedCheck(runtimeNode, args)) {
        return;
    }
    // Revert a false undefined check to a strict equality check
    final RuntimeNode newRuntimeNode;
    final Request request = runtimeNode.getRequest();
    if (Request.isUndefinedCheck(request)) {
        newRuntimeNode = runtimeNode.setRequest(request == Request.IS_UNDEFINED ? Request.EQ_STRICT : Request.NE_STRICT);
    } else {
        newRuntimeNode = runtimeNode;
    }

    new OptimisticOperation(newRuntimeNode, TypeBounds.UNBOUNDED) {
        @Override
        void loadStack() {
            for (final Expression arg : args) {
                loadExpression(arg, TypeBounds.OBJECT);
            }
        }
        @Override
        void consumeStack() {
            method.invokestatic(
                    CompilerConstants.className(ScriptRuntime.class),
                    newRuntimeNode.getRequest().toString(),
                    new FunctionSignature(
                        false,
                        false,
                        newRuntimeNode.getType(),
                        args.size()).toString());
        }
    }.emit();

    method.convert(newRuntimeNode.getType());
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
private void loadRuntimeNode(final RuntimeNode runtimeNode) {
    final List<Expression> args = new ArrayList<>(runtimeNode.getArgs());
    if (nullCheck(runtimeNode, args)) {
       return;
    } else if(undefinedCheck(runtimeNode, args)) {
        return;
    }
    // Revert a false undefined check to a strict equality check
    final RuntimeNode newRuntimeNode;
    final Request request = runtimeNode.getRequest();
    if (Request.isUndefinedCheck(request)) {
        newRuntimeNode = runtimeNode.setRequest(request == Request.IS_UNDEFINED ? Request.EQ_STRICT : Request.NE_STRICT);
    } else {
        newRuntimeNode = runtimeNode;
    }

    for (final Expression arg : args) {
        loadExpression(arg, TypeBounds.OBJECT);
    }

    method.invokestatic(
            CompilerConstants.className(ScriptRuntime.class),
            newRuntimeNode.getRequest().toString(),
            new FunctionSignature(
                false,
                false,
                newRuntimeNode.getType(),
                args.size()).toString());

    method.convert(newRuntimeNode.getType());
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
private Node leaveTYPEOF(final UnaryNode unaryNode) {
    final Expression rhs = unaryNode.getExpression();
    final List<Expression> args = new ArrayList<>();
    if (rhs instanceof IdentNode && !isParamOrVar((IdentNode) rhs)) {
        args.add(compilerConstantIdentifier(SCOPE));
        args.add(LiteralNode.newInstance(rhs, ((IdentNode) rhs).getName())); //null
    } else {
        args.add(rhs);
        args.add(LiteralNode.newInstance(unaryNode)); //null, do not reuse token of identifier rhs, it can be e.g. 'this'
    }
    final Node runtimeNode = new RuntimeNode(unaryNode, Request.TYPEOF, args);
    return runtimeNode;
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
private Node leaveBinaryRuntimeOperator(final BinaryNode binaryNode, final Request request) {
    try {
        // Don't do a full RuntimeNode.accept, as we don't want to double-visit the binary node operands
        return leaveRuntimeNode(new RuntimeNode(binaryNode, request));
    } finally {
        end(binaryNode);
    }
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
private boolean specializationCheck(final RuntimeNode.Request request, final Expression node, final List<Expression> args) {
    if (!request.canSpecialize()) {
        return false;
    }

    assert args.size() == 2;
    final Type returnType = node.getType();

    load(args.get(0));
    load(args.get(1));

    Request finalRequest = request;

    //if the request is a comparison, i.e. one that can be reversed
    //it keeps its semantic, but make sure that the object comes in
    //last
    final Request reverse = Request.reverse(request);
    if (method.peekType().isObject() && reverse != null) { //rhs is object
        if (!method.peekType(1).isObject()) { //lhs is not object
            method.swap(); //prefer object as lhs
            finalRequest = reverse;
        }
    }

    method.dynamicRuntimeCall(
            new SpecializedRuntimeNode(
                finalRequest,
                new Type[] {
                    method.peekType(1),
                    method.peekType()
                },
                returnType).getInitialName(),
            returnType,
            finalRequest);

    method.convert(node.getType());
    method.store(node.getSymbol());

    return true;
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
/**
 * Exit a comparison node and do the appropriate replacements. We need to introduce runtime
 * nodes late for comparisons as types aren't known until the last minute
 *
 * Both compares and adds may turn into runtimes node at this level as when we first bump
 * into the op in Attr, we may type it according to what we know there, which may be wrong later
 *
 * e.g. i (int) < 5 -> normal compare
 *     i = object
 *  then the post pass that would add the conversion to the 5 needs to
 *
 * @param binaryNode binary node to leave
 * @param request    runtime request
 * @return lowered cmp node
 */
@SuppressWarnings("fallthrough")
private Node leaveCmp(final BinaryNode binaryNode, final RuntimeNode.Request request) {
    final Expression lhs    = binaryNode.lhs();
    final Expression rhs    = binaryNode.rhs();

    Type widest = Type.widest(lhs.getType(), rhs.getType());

    boolean newRuntimeNode = false, finalized = false;
    switch (request) {
    case EQ_STRICT:
    case NE_STRICT:
        if (lhs.getType().isBoolean() != rhs.getType().isBoolean()) {
            newRuntimeNode = true;
            widest = Type.OBJECT;
            finalized = true;
        }
        //fallthru
    default:
        if (newRuntimeNode || widest.isObject()) {
            return new RuntimeNode(binaryNode, request).setIsFinal(finalized);
        }
        break;
    }

    return binaryNode.setLHS(convert(lhs, widest)).setRHS(convert(rhs, widest));
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
Request getRequest() {
    return request;
}
 

import jdk.nashorn.internal.ir.RuntimeNode.Request; //导入依赖的package包/类
private static Expression createIsUndefined(final Expression parent, final Expression lhs, final Expression rhs, final Request request) {
    if (isUndefinedIdent(lhs) || isUndefinedIdent(rhs)) {
        return new RuntimeNode(parent, request, lhs, rhs);
    }
    return parent;
}