Java BinaryNode.lhs方法代码示例

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
@Override
public boolean enterBinaryNode(final BinaryNode binaryNode) {
    if(binaryNode.isAssignment()) {
        final Expression lhs = binaryNode.lhs();
        if(!binaryNode.isSelfModifying()) {
            tagNeverOptimistic(lhs);
        }
        if(lhs instanceof IdentNode) {
            final Symbol symbol = ((IdentNode)lhs).getSymbol();
            // Assignment to internal symbols is never optimistic, except for self-assignment expressions
            if(symbol.isInternal() && !binaryNode.rhs().isSelfModifying()) {
                tagNeverOptimistic(binaryNode.rhs());
            }
        }
    } else if(binaryNode.isTokenType(TokenType.INSTANCEOF)) {
        tagNeverOptimistic(binaryNode.lhs());
        tagNeverOptimistic(binaryNode.rhs());
    }
    return true;
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
private void loadASSIGN(final BinaryNode binaryNode) {
    final Expression lhs = binaryNode.lhs();
    final Expression rhs = binaryNode.rhs();

    final Type rhsType = rhs.getType();
    // Detect dead assignments
    if(lhs instanceof IdentNode) {
        final Symbol symbol = ((IdentNode)lhs).getSymbol();
        if(!symbol.isScope() && !symbol.hasSlotFor(rhsType) && lc.getCurrentDiscard() == binaryNode) {
            loadAndDiscard(rhs);
            lc.popDiscard();
            method.markDeadLocalVariable(symbol);
            return;
        }
    }

    new Store<BinaryNode>(binaryNode, lhs) {
        @Override
        protected void evaluate() {
            // NOTE: we're loading with "at least as wide as" so optimistic operations on the right hand side
            // remain optimistic, and then explicitly convert to the required type if needed.
            loadExpressionAsType(rhs, rhsType);
        }
    }.store();
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
@Override
public boolean enterBinaryNode(final BinaryNode binaryNode) {
    if(binaryNode.isAssignment()) {
        final Expression lhs = binaryNode.lhs();
        if(!binaryNode.isSelfModifying()) {
            tagNeverOptimistic(lhs);
        }
        if(lhs instanceof IdentNode) {
            final Symbol symbol = ((IdentNode)lhs).getSymbol();
            // Assignment to internal symbols is never optimistic, except for self-assignment expressions
            if(symbol.isInternal() && !binaryNode.rhs().isSelfModifying()) {
                tagNeverOptimistic(binaryNode.rhs());
            }
        }
    } else if(binaryNode.isTokenType(TokenType.INSTANCEOF)
            || binaryNode.isTokenType(TokenType.EQ_STRICT)
            || binaryNode.isTokenType(TokenType.NE_STRICT)) {
        tagNeverOptimistic(binaryNode.lhs());
        tagNeverOptimistic(binaryNode.rhs());
    }
    return true;
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
private void loadASSIGN(final BinaryNode binaryNode) {
    final Expression lhs = binaryNode.lhs();
    final Expression rhs = binaryNode.rhs();

    final Type rhsType = rhs.getType();
    // Detect dead assignments
    if(lhs instanceof IdentNode) {
        final Symbol symbol = ((IdentNode)lhs).getSymbol();
        if(!symbol.isScope() && !symbol.hasSlotFor(rhsType) && lc.popDiscardIfCurrent(binaryNode)) {
            loadAndDiscard(rhs);
            method.markDeadLocalVariable(symbol);
            return;
        }
    }

    new Store<BinaryNode>(binaryNode, lhs) {
        @Override
        protected void evaluate() {
            // NOTE: we're loading with "at least as wide as" so optimistic operations on the right hand side
            // remain optimistic, and then explicitly convert to the required type if needed.
            loadExpressionAsType(rhs, rhsType);
        }
    }.store();
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
@Override
public Node leaveBinaryNode(final BinaryNode binaryNode) {
    if (binaryNode.isAssignment() && binaryNode.lhs() instanceof IdentNode) {
        checkConstAssignment((IdentNode) binaryNode.lhs());
    }
    switch (binaryNode.tokenType()) {
    case ASSIGN:
        return leaveASSIGN(binaryNode);
    default:
        return super.leaveBinaryNode(binaryNode);
    }
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
private Node leaveASSIGN(final BinaryNode binaryNode) {
    // If we're assigning a property of the this object ("this.foo = ..."), record it.
    final Expression lhs = binaryNode.lhs();
    if (lhs instanceof AccessNode) {
        final AccessNode accessNode = (AccessNode) lhs;
        final Expression base = accessNode.getBase();
        if (base instanceof IdentNode) {
            final Symbol symbol = ((IdentNode)base).getSymbol();
            if(symbol.isThis()) {
                thisProperties.peek().add(accessNode.getProperty());
            }
        }
    }
    return binaryNode;
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
@Override
public boolean enterASSIGN(BinaryNode binaryNode) {
    if (es6 && (binaryNode.lhs() instanceof ObjectNode || binaryNode.lhs() instanceof ArrayLiteralNode)) {
        throwNotImplementedYet("es6.destructuring", binaryNode);
    }
    return super.enterASSIGN(binaryNode);
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
@Override
public boolean enterBinaryNode(final BinaryNode binaryNode) {
    // NOTE: regardless of operator's lexical associativity, lhs is always evaluated first.
    final Expression lhs = binaryNode.lhs();
    final LvarType lhsType;
    if (!(lhs instanceof IdentNode && binaryNode.isTokenType(TokenType.ASSIGN))) {
        lhsType = visitExpression(lhs);
    } else {
        // Can't visit IdentNode on LHS of a simple assignment, as visits imply use, and this is def.
        // The type is irrelevant, as only RHS is used to determine the type anyway.
        lhsType = LvarType.UNDEFINED;
    }

    final boolean isLogical = binaryNode.isLogical();
    final Label joinLabel = isLogical ? new Label("") : null;
    if(isLogical) {
        jumpToLabel((JoinPredecessor)lhs, joinLabel);
    }

    final Expression rhs = binaryNode.rhs();
    final LvarType rhsType = visitExpression(rhs);
    if(isLogical) {
        jumpToLabel((JoinPredecessor)rhs, joinLabel);
    }
    joinOnLabel(joinLabel);

    final LvarType type = toLvarType(binaryNode.setOperands(lhsType.typeExpression, rhsType.typeExpression).getType());

    if(binaryNode.isAssignment() && lhs instanceof IdentNode) {
        if(binaryNode.isSelfModifying()) {
            onSelfAssignment((IdentNode)lhs, type);
        } else {
            onAssignment((IdentNode)lhs, type);
        }
    }
    typeStack.push(type);
    return false;
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
BinarySelfAssignment(final BinaryNode node) {
    super(node, node.lhs());
}
 

import jdk.nashorn.internal.ir.BinaryNode; //导入方法依赖的package包/类
/**
 * Constructor
 *
 * @param node the assign op node
 */
BinaryOptimisticSelfAssignment(final BinaryNode node) {
    super(node, node.lhs());
}