import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
protected int diffBinary(JCBinary oldT, JCBinary newT, int[] bounds) {
    int localPointer = bounds[0];

    int[] lhsBounds = getBounds(oldT.lhs);
    copyTo(localPointer, lhsBounds[0]);
    localPointer = diffTree(oldT.lhs, newT.lhs, lhsBounds);
    if (oldT.getTag() != newT.getTag()) {
        copyTo(localPointer, oldT.pos);
        printer.print(operatorName(newT.getTag()));
        localPointer = oldT.pos + operatorName(oldT.getTag()).toString().length();
    }
    int[] rhsBounds = getCommentCorrectedBounds(oldT.rhs);
    rhsBounds[0] = copyUpTo(localPointer, rhsBounds[0]);
    localPointer = diffTree(oldT.rhs, newT.rhs, rhsBounds);
    return copyUpTo(localPointer, bounds[1]);
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
@Override
public List<JCTree> translateTopLevelClass(Env<AttrContext> env, JCTree cdef, TreeMaker make) {
    List<JCTree> result = super.translateTopLevelClass(env, cdef, make);

    new TreeScanner() {
        @Override
        public void visitBinary(JCBinary tree) {
            hasNullCheck |= tree.operator.getSimpleName().contentEquals("!=") &&
                            "resource".equals(String.valueOf(TreeInfo.name(tree.lhs))) &&
                            TreeInfo.isNull(tree.rhs);
            super.visitBinary(tree);
        }
    }.scan(result);

    return result;
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
/**
 * This function walks into a tree with nodes of type JCBinary to search for 
 * a string as one of the elements of the tree.
 * @param toTest The String searched as Element in the tree.
 * @param expression The bifurcation tree searched.
 * @return True if the string was found, or False.
 */
private boolean isThereInMiniTree(String toTest, JCTree expression) {
	if(expression instanceof JCParens){
		if(isThereInMiniTree(toTest, ((JCParens) expression).expr))
			return true;
	} else if(expression instanceof JCIdent){
		if(((JCIdent) expression).name.toString().equals(toTest))
			return true;
	} else if(expression instanceof JCBinary){
		if(isThereInMiniTree(toTest, ((JCBinary) expression).rhs))
			return true;
		if(isThereInMiniTree(toTest, ((JCBinary) expression).lhs))
			return true;
	}
	return false;
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
/**
 * Verify if the boolean expression have a true value despite of any variable values. 
 * @param expression The boolean expression examined.
 * @return 1 When the expression is always true.
 */
private int hasTrueValue(JCTree expression) {
	if(expression instanceof JCParens){
		if(hasTrueValue(((JCParens)expression).expr) != 0)
			return 1;
	}else if(expression instanceof JCLiteral){
		if(((JCLiteral) expression).value == null)
			return VAR_FALSE_VALUE;
		return (int) ((JCLiteral) expression).value;
	}else if(expression instanceof JmlSingleton){
		return 1;
	}else if(expression instanceof JCBinary){
		return resolveBooleanOperations(expression);
	}
	return VAR_FALSE_VALUE;
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
@Override
public Description matchBinary(BinaryTree tree, VisitorState state) {
  Tree parent = state.getPath().getParentPath().getLeaf();
  if (!(parent instanceof BinaryTree)) {
    return NO_MATCH;
  }
  if (TreeInfo.opPrec(((JCBinary) tree).getTag())
      == TreeInfo.opPrec(((JCBinary) parent).getTag())) {
    return NO_MATCH;
  }
  if (!isConfusing(tree.getKind(), parent.getKind())) {
    return NO_MATCH;
  }
  return describeMatch(
      tree, SuggestedFix.builder().prefixWith(tree, "(").postfixWith(tree, ")").build());
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
@Override public void visitBinary(JCBinary tree) {
	String op = operator(treeTag(tree));
	print(tree.lhs);
	print(" ");
	print(op);
	print(" ");
	print(tree.rhs);
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
public JCStatement generateCompareFloatOrDouble(JCExpression thisDotField, JCExpression otherDotField,
	JavacTreeMaker maker, JavacNode node, boolean isDouble) {
	
	/* if (Float.compare(fieldName, other.fieldName) != 0) return false; */
	JCExpression clazz = genJavaLangTypeRef(node, isDouble ? "Double" : "Float");
	List<JCExpression> args = List.of(thisDotField, otherDotField);
	JCBinary compareCallEquals0 = maker.Binary(CTC_NOT_EQUAL, maker.Apply(
		List.<JCExpression>nil(), maker.Select(clazz, node.toName("compare")), args), maker.Literal(0));
	return maker.If(compareCallEquals0, returnBool(maker, false), null);
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
/**
 * Checks if the statement is of the form 'if (x == null) {throw WHATEVER;},
 * where the block braces are optional. If it is of this form, returns "x".
 * If it is not of this form, returns null.
 */
public String returnVarNameIfNullCheck(JCStatement stat) {
	if (!(stat instanceof JCIf)) return null;
	
	/* Check that the if's statement is a throw statement, possibly in a block. */ {
		JCStatement then = ((JCIf) stat).thenpart;
		if (then instanceof JCBlock) {
			List<JCStatement> stats = ((JCBlock) then).stats;
			if (stats.length() == 0) return null;
			then = stats.get(0);
		}
		if (!(then instanceof JCThrow)) return null;
	}
	
	/* Check that the if's conditional is like 'x == null'. Return from this method (don't generate
	   a nullcheck) if 'x' is equal to our own variable's name: There's already a nullcheck here. */ {
		JCExpression cond = ((JCIf) stat).cond;
		while (cond instanceof JCParens) cond = ((JCParens) cond).expr;
		if (!(cond instanceof JCBinary)) return null;
		JCBinary bin = (JCBinary) cond;
		if (!CTC_EQUAL.equals(treeTag(bin))) return null;
		if (!(bin.lhs instanceof JCIdent)) return null;
		if (!(bin.rhs instanceof JCLiteral)) return null;
		if (!CTC_BOT.equals(typeTag(bin.rhs))) return null;
		return ((JCIdent) bin.lhs).name.toString();
	}
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
public void visitBinary(JCBinary that) {
    try {
        print("JCBinary:");
    } catch (Exception e) {
    }
    super.visitBinary(that);
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
public void visitBinary(JCBinary tree) {
	try {
		int ownprec = isOwnPrec(tree);
		String opname = operatorName(treeTag(tree));
		open(prec, ownprec);
		printExpr(tree.lhs, ownprec);
		print(" " + opname + " ");
		printExpr(tree.rhs, ownprec + 1);
		close(prec, ownprec);
	} catch (IOException e) {
		throw new UncheckedIOException(e);
	}
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
public JCStatement generateCompareFloatOrDouble(JCExpression thisDotField, JCExpression otherDotField,
		JavacTreeMaker maker, JavacNode node, boolean isDouble) {
	/* if (Float.compare(fieldName, other.fieldName) != 0) return false; */
	JCExpression clazz = genJavaLangTypeRef(node, isDouble ? "Double" : "Float");
	List<JCExpression> args = List.of(thisDotField, otherDotField);
	JCBinary compareCallEquals0 = maker.Binary(CTC_NOT_EQUAL, maker.Apply(
			List.<JCExpression>nil(), maker.Select(clazz, node.toName("compare")), args), maker.Literal(0));
	return maker.If(compareCallEquals0, returnBool(maker, false), null);
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
@Override
public JCBinary inline(Inliner inliner) throws CouldNotResolveImportException {
  return inliner.maker().Binary(
      OP_CODES.get(getKind()), 
      getLeftOperand().inline(inliner),
      getRightOperand().inline(inliner));
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
@Override public void visitBinary(JCBinary tree) {
	printNode(tree);
	child("lhs", tree.lhs);
	property("(operator)", operatorName(getTag(tree)));
	child("rhs", tree.rhs);
	indent--;
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
@Override public void visitBinary(JCBinary node) {
	BinaryExpression expr = new BinaryExpression();
	expr.rawLeft(toTree(node.getLeftOperand()));
	expr.rawRight(toTree(node.getRightOperand()));
	expr.astOperator(JcTreeBuilder.BINARY_OPERATORS.inverse().get(getTag(node)));
	set(node, expr);
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
@Override
public JCBinary inline(Inliner inliner) throws CouldNotResolveImportException {
  return inliner
      .maker()
      .Binary(
          OP_CODES.get(getKind()),
          getLeftOperand().inline(inliner),
          getRightOperand().inline(inliner));
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
@Override
public Choice<State<JCBinary>> visitBinary(final BinaryTree node, State<?> state) {
  final Tag tag = ((JCBinary) node).getTag();
  return chooseSubtrees(
      state,
      s -> unifyExpression(node.getLeftOperand(), s),
      s -> unifyExpression(node.getRightOperand(), s),
      (l, r) -> maker().Binary(tag, l, r));
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
/** Desugars a compound assignment, making the cast explicit. */
private static Optional<Fix> rewriteCompoundAssignment(
    CompoundAssignmentTree tree, VisitorState state) {
  CharSequence var = state.getSourceForNode(tree.getVariable());
  CharSequence expr = state.getSourceForNode(tree.getExpression());
  if (var == null || expr == null) {
    return Optional.absent();
  }
  switch (tree.getKind()) {
    case RIGHT_SHIFT_ASSIGNMENT:
      // narrowing the result of a signed right shift does not lose information
      return Optional.absent();
    default:
      break;
  }
  Kind regularAssignmentKind = regularAssignmentFromCompound(tree.getKind());
  String op = assignmentToString(regularAssignmentKind);

  // Add parens to the rhs if necessary to preserve the current precedence
  // e.g. 's -= 1 - 2' -> 's = s - (1 - 2)'
  if (tree.getExpression() instanceof JCBinary) {
    Kind rhsKind = tree.getExpression().getKind();
    if (!OperatorPrecedence.from(rhsKind)
        .isHigher(OperatorPrecedence.from(regularAssignmentKind))) {
      expr = String.format("(%s)", expr);
    }
  }

  // e.g. 's *= 42' -> 's = (short) (s * 42)'
  String castType = getType(tree.getVariable()).toString();
  String replacement = String.format("%s = (%s) (%s %s %s)", var, castType, var, op, expr);
  return Optional.of(SuggestedFix.replace(tree, replacement));
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
public void visitBinary(JCBinary tree) {
    try {
        int ownprec = TreeInfo.opPrec(tree.getTag());
        String opname = operatorName(tree.getTag());
        open(prec, ownprec);
        printExpr(tree.lhs, ownprec);
        print(" " + opname + " ");
        printExpr(tree.rhs, ownprec + 1);
        close(prec, ownprec);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
public void visitBinary(JCBinary tree) {
    try {
        int ownprec = TreeInfo.opPrec(getTag(tree));
        String opname = operatorName(getTag(tree));
        open(prec, ownprec);
        printExpr(tree.lhs, ownprec);
        print(" " + opname + " ");
        printExpr(tree.rhs, ownprec + 1);
        close(prec, ownprec);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

import com.sun.tools.javac.tree.JCTree.JCBinary; //导入依赖的package包/类
private JCStatement generateCompareFloatOrDouble(JCExpression thisDotField, JCExpression otherDotField,
		TreeMaker maker, JavacNode node, boolean isDouble) {
	/* if (Float.compare(fieldName, other.fieldName) != 0) return false; */
	JCExpression clazz = chainDots(node, "java", "lang", isDouble ? "Double" : "Float");
	List<JCExpression> args = List.of(thisDotField, otherDotField);
	JCBinary compareCallEquals0 = maker.Binary(CTC_NOT_EQUAL, maker.Apply(
			List.<JCExpression>nil(), maker.Select(clazz, node.toName("compare")), args), maker.Literal(0));
	return maker.If(compareCallEquals0, returnBool(maker, false), null);
}