Java Token.DELPROP属性代码示例

/**
 * Returns true if the current node's type implies side effects.
 *
 * This is a non-recursive version of the may have side effects
 * check; used to check wherever the current node's type is one of
 * the reason's why a subtree has side effects.
 */
static boolean nodeTypeMayHaveSideEffects(Node n) {
  if (NodeUtil.isAssignmentOp(n)) {
    return true;
  }

  switch(n.getType()) {
    case Token.CALL:
    case Token.DELPROP:
    case Token.NEW:
    case Token.DEC:
    case Token.INC:
    case Token.THROW:
      return true;
    case Token.NAME:
      // A variable definition.
      return n.hasChildren();
    default:
      return false;
  }
}
 

/**
 * @return Whether the node may have non-local side-effects.
 */
private boolean hasNonLocalSideEffect(Node n) {
  boolean sideEffect = false;
  int type = n.getType();
  // Note: Only care about changes to non-local names, specifically
  // ignore VAR declaration assignments.
  if (NodeUtil.isAssignmentOp(n)
      || type == Token.INC
      || type == Token.DEC) {
    Node lhs = n.getFirstChild();
    // Ignore changes to local names.
    if (!isLocalName(lhs)) {
      sideEffect = true;
    }
  } else if (type == Token.CALL) {
    sideEffect = NodeUtil.functionCallHasSideEffects(n);
  } else if (type == Token.NEW) {
    sideEffect = NodeUtil.constructorCallHasSideEffects(n);
  } else if (type == Token.DELPROP) {
    sideEffect = true;
  }

  return sideEffect;
}
 

@Override public void visit(NodeTraversal t, Node n, Node parent) {
  if (n.getType() == Token.WITH) {
    t.report(n, WITH_DISALLOWED);
  } else if (n.getType() == Token.NAME) {
    if (!NodeUtil.isLabelName(n) && !isDeclaration(n)) {
      checkNameUse(t, n);
    }
  } else if (n.getType() == Token.ASSIGN) {
    checkAssignment(t, n);
  } else if (n.getType() == Token.DELPROP) {
    checkDelete(t, n);
  } else if (n.getType() == Token.OBJECTLIT) {
    checkObjectLiteral(t, n);
  } else if (n.getType() == Token.LABEL) {
    checkLabel(t, n);
  }
}
 

static int precedence(int type) {
  switch (type) {
    case Token.COMMA:  return 0;
    case Token.ASSIGN_BITOR:
    case Token.ASSIGN_BITXOR:
    case Token.ASSIGN_BITAND:
    case Token.ASSIGN_LSH:
    case Token.ASSIGN_RSH:
    case Token.ASSIGN_URSH:
    case Token.ASSIGN_ADD:
    case Token.ASSIGN_SUB:
    case Token.ASSIGN_MUL:
    case Token.ASSIGN_DIV:
    case Token.ASSIGN_MOD:
    case Token.ASSIGN: return 1;
    case Token.HOOK:   return 2;  // ?: operator
    case Token.OR:     return 3;
    case Token.AND:    return 4;
    case Token.BITOR:  return 5;
    case Token.BITXOR: return 6;
    case Token.BITAND: return 7;
    case Token.EQ:
    case Token.NE:
    case Token.SHEQ:
    case Token.SHNE:   return 8;
    case Token.LT:
    case Token.GT:
    case Token.LE:
    case Token.GE:
    case Token.INSTANCEOF:
    case Token.IN:     return 9;
    case Token.LSH:
    case Token.RSH:
    case Token.URSH:   return 10;
    case Token.SUB:
    case Token.ADD:    return 11;
    case Token.MUL:
    case Token.MOD:
    case Token.DIV:    return 12;
    case Token.INC:
    case Token.DEC:
    case Token.NEW:
    case Token.DELPROP:
    case Token.TYPEOF:
    case Token.VOID:
    case Token.NOT:
    case Token.BITNOT:
    case Token.POS:
    case Token.NEG:    return 13;

    case Token.ARRAYLIT:
    case Token.CALL:
    case Token.EMPTY:
    case Token.FALSE:
    case Token.FUNCTION:
    case Token.GETELEM:
    case Token.GETPROP:
    case Token.GET_REF:
    case Token.IF:
    case Token.LP:
    case Token.NAME:
    case Token.NULL:
    case Token.NUMBER:
    case Token.OBJECTLIT:
    case Token.REGEXP:
    case Token.RETURN:
    case Token.STRING:
    case Token.THIS:
    case Token.TRUE:
      return 15;

    default: throw new Error("Unknown precedence for " +
                             Node.tokenToName(type) +
                             " (type " + type + ")");
  }
}
 

@Override
public void visit(NodeTraversal traversal, Node node, Node parent) {

  if (inExterns) {
    return;
  }

  if (!NodeUtil.nodeTypeMayHaveSideEffects(node)) {
    return;
  }

  if (NodeUtil.isCall(node) || NodeUtil.isNew(node)) {
    allFunctionCalls.add(node);
  }

  Node enclosingFunction = traversal.getEnclosingFunction();
  if (enclosingFunction != null) {
    FunctionInformation sideEffectInfo =
        functionSideEffectMap.get(enclosingFunction);
    Preconditions.checkNotNull(sideEffectInfo);

    if (NodeUtil.isAssignmentOp(node)) {
      visitAssignmentOrUnaryOperatorLhs(
          sideEffectInfo, traversal.getScope(), node.getFirstChild());
    } else {
      switch(node.getType()) {
        case Token.CALL:
        case Token.NEW:
          visitCall(sideEffectInfo, node);
          break;
        case Token.DELPROP:
        case Token.DEC:
        case Token.INC:
          visitAssignmentOrUnaryOperatorLhs(
              sideEffectInfo, traversal.getScope(), node.getFirstChild());
          break;
        case Token.NAME:

          // Variable definition are not side effects.
          // Just check that the name appears in the context of a
          // variable declaration.
          Preconditions.checkArgument(
              NodeUtil.isVarDeclaration(node));
          break;
        case Token.THROW:
          visitThrow(sideEffectInfo);
          break;
        default:
          throw new IllegalArgumentException(
              "Unhandled side effect node type " +
              Token.name(node.getType()));
      }
    }
  }
}