Java Code Examples for com.google.javascript.rhino.Node#isEquivalentTo()

private void tryConvertToNumber(Node n) {
  switch (n.getType()) {
    case Token.NUMBER:
      // Nothing to do
      return;
    case Token.AND:
    case Token.OR:
    case Token.COMMA:
      tryConvertToNumber(n.getLastChild());
      return;
    case Token.HOOK:
      tryConvertToNumber(n.getChildAtIndex(1));
      tryConvertToNumber(n.getLastChild());
      return;
    case Token.NAME:
      if (!NodeUtil.isUndefined(n)) {
        return;
      }
      break;
  }

  Double result = NodeUtil.getNumberValue(n);
  if (result == null) {
    return;
  }

  double value = result;

  Node replacement = NodeUtil.numberNode(value, n);
  if (replacement.isEquivalentTo(n)) {
    return;
  }

  n.getParent().replaceChild(n, replacement);
  reportCodeChange();
}
 

/**
 * Replaces a node with a number node if the new number node is not equivalent
 * to the current node.
 */
private void maybeReplaceChildWithNumber(NodeTraversal t, Node n, Node parent,
    int num) {
  Node newNode = Node.newNumber(num);
  if(!newNode.isEquivalentTo(n)) {
    parent.replaceChild(n, newNode);
    t.getCompiler().reportCodeChange();
  }
}
 

/**
 * Replaces a node with a number node if the new number node is not equivalent
 * to the current node.
 */
private void maybeReplaceChildWithNumber(NodeTraversal t, Node n, Node parent,
    int num) {
  Node newNode = Node.newNumber(num);
  if(!newNode.isEquivalentTo(n)) {
    parent.replaceChild(n, newNode);
    t.getCompiler().reportCodeChange();
  }
}
 

/**
 * Replaces a node with a number node if the new number node is not equivalent
 * to the current node.
 *
 * Returns the replacement for n if it was replaced, otherwise returns n.
 */
private Node maybeReplaceChildWithNumber(Node n, Node parent, int num) {
  Node newNode = IR.number(num);
  if (!newNode.isEquivalentTo(n)) {
    parent.replaceChild(n, newNode);
    reportCodeChange();

    return newNode;
  }

  return n;
}
 

/**
 * Replaces a node with a number node if the new number node is not equivalent
 * to the current node.
 *
 * Returns the replacement for n if it was replaced, otherwise returns n.
 */
private Node maybeReplaceChildWithNumber(Node n, Node parent, int num) {
  Node newNode = IR.number(num);
  if (!newNode.isEquivalentTo(n)) {
    parent.replaceChild(n, newNode);
    reportCodeChange();

    return newNode;
  }

  return n;
}
 

@Override
boolean areNodesEqualForInlining(Node n1, Node n2) {
  if (options.ambiguateProperties ||
      options.disambiguateProperties) {
    // The type based optimizations require that type information is preserved
    // during other optimizations.
    return n1.isEquivalentToTyped(n2);
  } else {
    return n1.isEquivalentTo(n2);
  }
}
 

@Override
boolean areNodesEqualForInlining(Node n1, Node n2) {
  if (options.ambiguateProperties ||
      options.disambiguateProperties) {
    // The type based optimizations require that type information is preserved
    // during other optimizations.
    return n1.isEquivalentToTyped(n2);
  } else {
    return n1.isEquivalentTo(n2);
  }
}
 

private void tryConvertToNumber(Node n) {
  switch (n.getType()) {
    case Token.NUMBER:
      // Nothing to do
      return;
    case Token.AND:
    case Token.OR:
    case Token.COMMA:
      tryConvertToNumber(n.getLastChild());
      return;
    case Token.HOOK:
      tryConvertToNumber(n.getChildAtIndex(1));
      tryConvertToNumber(n.getLastChild());
      return;
    case Token.NAME:
      if (!NodeUtil.isUndefined(n)) {
        return;
      }
      break;
  }

  Double result = NodeUtil.getNumberValue(n);
  if (result == null) {
    return;
  }

  double value = result;

  Node replacement = NodeUtil.numberNode(value, n);
  if (replacement.isEquivalentTo(n)) {
    return;
  }

  n.getParent().replaceChild(n, replacement);
  reportCodeChange();
}
 

/**
 * Determine which parameters use the same expression.
 * @return Whether any parameter was found that can be updated.
 */
private boolean findFixedParameters(List<Parameter> parameters, Node cur) {
  boolean anyMovable = false;
  int index = 0;
  while ((cur = cur.getNext()) != null) {
    Parameter p;
    if (index >= parameters.size()) {
      p = new Parameter(cur, false);
      parameters.add(p);
    } else {
      p = parameters.get(index);
      if (p.shouldRemove()) {
        Node value = p.getArg();
        if (!cur.isEquivalentTo(value)) {
          p.setShouldRemove(false);
        } else {
          anyMovable = true;
        }
      }
    }

    setParameterSideEffectInfo(p, cur);
    index++;
  }

  for (;index < parameters.size(); index++) {
    parameters.get(index).setShouldRemove(false);
  }

  return anyMovable;
}
 

/**
 * Replaces a node with a number node if the new number node is not equivalent
 * to the current node.
 *
 * Returns the replacement for n if it was replaced, otherwise returns n.
 */
private Node maybeReplaceChildWithNumber(Node n, Node parent, int num) {
  Node newNode = Node.newNumber(num);
  if (!newNode.isEquivalentTo(n)) {
    parent.replaceChild(n, newNode);
    reportCodeChange();

    return newNode;
  }

  return n;
}
 

@Override
boolean areNodesEqualForInlining(Node n1, Node n2) {
  if (options.ambiguateProperties ||
      options.disambiguateProperties) {
    // The type based optimizations require that type information is preserved
    // during other optimizations.
    return n1.isEquivalentToTyped(n2);
  } else {
    return n1.isEquivalentTo(n2);
  }
}
 

private void overrideDefines(Map<String, DefineInfo> allDefines) {
  boolean changed = false;
  for (Map.Entry<String, DefineInfo> def : allDefines.entrySet()) {
    String defineName = def.getKey();
    DefineInfo info = def.getValue();
    Node inputValue = dominantReplacements.get(defineName);
    Node finalValue = inputValue != null ?
        inputValue : info.getLastValue();
    if (finalValue != info.initialValue) {
      info.initialValueParent.replaceChild(
          info.initialValue, finalValue.cloneTree());
      compiler.addToDebugLog("Overriding @define variable " + defineName);
      changed = changed ||
          finalValue.getType() != info.initialValue.getType() ||
          !finalValue.isEquivalentTo(info.initialValue);
    }
  }

  if (changed) {
    compiler.reportCodeChange();
  }

  Set<String> unusedReplacements = dominantReplacements.keySet();
  unusedReplacements.removeAll(allDefines.keySet());
  unusedReplacements.removeAll(KNOWN_DEFINES);
  for (String unknownDefine : unusedReplacements) {
    compiler.report(JSError.make(UNKNOWN_DEFINE_WARNING, unknownDefine));
  }
}
 

/**
 * Replaces a node with a number node if the new number node is not equivalent
 * to the current node.
 *
 * Returns the replacement for n if it was replaced, otherwise returns n.
 */
private Node maybeReplaceChildWithNumber(Node n, Node parent, int num) {
  Node newNode = Node.newNumber(num);
  if (!newNode.isEquivalentTo(n)) {
    parent.replaceChild(n, newNode);
    reportCodeChange();

    return newNode;
  }

  return n;
}
 

private void tryConvertToNumber(Node n) {
  switch (n.getType()) {
    case Token.NUMBER:
      // Nothing to do
      return;
    case Token.AND:
    case Token.OR:
    case Token.COMMA:
      tryConvertToNumber(n.getLastChild());
      return;
    case Token.HOOK:
      tryConvertToNumber(n.getChildAtIndex(1));
      tryConvertToNumber(n.getLastChild());
      return;
    case Token.NAME:
      if (!NodeUtil.isUndefined(n)) {
        return;
      }
      break;
  }

  Double result = NodeUtil.getNumberValue(n);
  if (result == null) {
    return;
  }

  double value = result;

  Node replacement = NodeUtil.numberNode(value, n);
  if (replacement.isEquivalentTo(n)) {
    return;
  }

  n.getParent().replaceChild(n, replacement);
  reportCodeChange();
}
 

@Override
boolean areNodesEqualForInlining(Node n1, Node n2) {
  if (options.ambiguateProperties ||
      options.disambiguateProperties) {
    // The type based optimizations require that type information is preserved
    // during other optimizations.
    return n1.isEquivalentToTyped(n2);
  } else {
    return n1.isEquivalentTo(n2);
  }
}
 

@Override
boolean areNodesEqualForInlining(Node n1, Node n2) {
  if (options.ambiguateProperties ||
      options.disambiguateProperties) {
    // The type based optimizations require that type information is preserved
    // during other optimizations.
    return n1.isEquivalentToTyped(n2);
  } else {
    return n1.isEquivalentTo(n2);
  }
}
 

/**
 * Check whether one exit can be replaced with another. Verify:
 * 1) They are identical expressions
 * 2) If an exception is possible that the statements, the original
 * and the potential replacement are in the same exception handler.
 */
boolean areMatchingExits(Node nodeThis, Node nodeThat) {
  return nodeThis.isEquivalentTo(nodeThat)
      && (!isExceptionPossible(nodeThis)
          || getExceptionHandler(nodeThis) == getExceptionHandler(nodeThat));
}
 

/**
 * Check whether one exit can be replaced with another. Verify:
 * 1) They are identical expressions
 * 2) If an exception is possible that the statements, the original
 * and the potential replacement are in the same exception handler.
 */
boolean areMatchingExits(Node nodeThis, Node nodeThat) {
  return nodeThis.isEquivalentTo(nodeThat)
      && (!isExceptionPossible(nodeThis)
          || getExceptionHandler(nodeThis) == getExceptionHandler(nodeThat));
}
 

/**
 * Check whether one exit can be replaced with another. Verify:
 * 1) They are identical expressions
 * 2) If an exception is possible that the statements, the original
 * and the potential replacement are in the same exception handler.
 */
boolean areMatchingExits(Node nodeThis, Node nodeThat) {
  return nodeThis.isEquivalentTo(nodeThat)
      && (!isExceptionPossible(nodeThis)
          || getExceptionHandler(nodeThis) == getExceptionHandler(nodeThat));
}
 

/**
 * Check whether one exit can be replaced with another. Verify:
 * 1) They are identical expressions
 * 2) If an exception is possible that the statements, the original
 * and the potential replacement are in the same exception handler.
 */
boolean areMatchingExits(Node nodeThis, Node nodeThat) {
  return nodeThis.isEquivalentTo(nodeThat)
      && (!isExceptionPossible(nodeThis)
          || getExceptionHandler(nodeThis) == getExceptionHandler(nodeThat));
}