jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Lower.java

equal deleted inserted replaced

-:563b42fc70ba
+:36468b5fa7f4
 return builder.build(lval);
 case SELECT: {
 final JCFieldAccess s = (JCFieldAccess)lval;
 Symbol lid = TreeInfo.symbol(s.selected);
 if (lid != null && lid.kind == TYP) return builder.build(lval);
-return abstractRval(s.selected, new TreeBuilder() {
+return abstractRval(s.selected, selected -> builder.build(make.Select(selected, s.sym)));
-public JCExpression build(final JCExpression selected) {
-return builder.build(make.Select(selected, s.sym));
-}
-});
 }
 case INDEXED: {
 final JCArrayAccess i = (JCArrayAccess)lval;
-return abstractRval(i.indexed, new TreeBuilder() {
+return abstractRval(i.indexed, indexed -> abstractRval(i.index, syms.intType, index -> {
-public JCExpression build(final JCExpression indexed) {
+JCExpression newLval = make.Indexed(indexed, index);
-return abstractRval(i.index, syms.intType, new TreeBuilder() {
+newLval.setType(i.type);
-public JCExpression build(final JCExpression index) {
+return builder.build(newLval);
-JCExpression newLval = make.Indexed(indexed, index);
+}));
-newLval.setType(i.type);
-return builder.build(newLval);
-}
-});
-}
-});
 }
 case TYPECAST: {
 return abstractLval(((JCTypeCast)lval).expr, builder);
 }
 }
 throw new AssertionError(lval);
 }
 // evaluate and discard the first expression, then evaluate the second.
 JCExpression makeComma(final JCExpression expr1, final JCExpression expr2) {
-return abstractRval(expr1, new TreeBuilder() {
+return abstractRval(expr1, discarded -> expr2);
-public JCExpression build(final JCExpression discarded) {
-return expr2;
-}
-});
 }
 /**************************************************************************
 * Translation methods
 *************************************************************************/
 if (boxingReq || depScanner.dependencyFound) {
 // boxing required; need to rewrite as x = (unbox typeof x)(x op y);
 // or if x == (typeof x)z then z = (unbox typeof x)((typeof x)z op y)
 // (but without recomputing x)
-JCTree newTree = abstractLval(tree.lhs, new TreeBuilder() {
+JCTree newTree = abstractLval(tree.lhs, lhs -> {
-public JCExpression build(final JCExpression lhs) {
+Tag newTag = tree.getTag().noAssignOp();
-JCTree.Tag newTag = tree.getTag().noAssignOp();
+// Erasure (TransTypes) can change the type of
-// Erasure (TransTypes) can change the type of
+// tree.lhs.  However, we can still get the
-// tree.lhs.  However, we can still get the
+// unerased type of tree.lhs as it is stored
-// unerased type of tree.lhs as it is stored
+// in tree.type in Attr.
-// in tree.type in Attr.
+OperatorSymbol newOperator = operators.resolveBinary(tree,
-OperatorSymbol newOperator = operators.resolveBinary(tree,
+newTag,
-newTag,
+tree.type,
-tree.type,
+tree.rhs.type);
-tree.rhs.type);
+//Need to use the "lhs" at two places, once on the future left hand side
-//Need to use the "lhs" at two places, once on the future left hand side
+//and once in the future binary operator. But further processing may change
-//and once in the future binary operator. But further processing may change
+//the components of the tree in place (see visitSelect for e.g. <Class>.super.<ident>),
-//the components of the tree in place (see visitSelect for e.g. <Class>.super.<ident>),
+//so cloning the tree to avoid interference between the uses:
-//so cloning the tree to avoid interference between the uses:
+JCExpression expr = (JCExpression) lhs.clone();
-JCExpression expr = (JCExpression) lhs.clone();
+if (expr.type != tree.type)
-if (expr.type != tree.type)
+expr = make.TypeCast(tree.type, expr);
-expr = make.TypeCast(tree.type, expr);
+JCBinary opResult = make.Binary(newTag, expr, tree.rhs);
-JCBinary opResult = make.Binary(newTag, expr, tree.rhs);
+opResult.operator = newOperator;
-opResult.operator = newOperator;
+opResult.type = newOperator.type.getReturnType();
-opResult.type = newOperator.type.getReturnType();
+JCExpression newRhs = boxingReq ?
-JCExpression newRhs = boxingReq ?
+make.TypeCast(types.unboxedType(tree.type), opResult) :
-make.TypeCast(types.unboxedType(tree.type), opResult) :
+opResult;
-opResult;
+return make.Assign(lhs, newRhs).setType(tree.type);
-return make.Assign(lhs, newRhs).setType(tree.type);
+});
-}
-});
 result = translate(newTree);
 return;
 }
 tree.lhs = translate(tree.lhs, tree);
 tree.rhs = translate(tree.rhs, tree.operator.type.getParameterTypes().tail.head);
 // translate to tmp1=lval(e); tmp2=tmp1; tmp1 OP 1; tmp2
 // or
 // translate to tmp1=lval(e); tmp2=tmp1; (typeof tree)tmp1 OP 1; tmp2
 // where OP is += or -=
 final boolean cast = TreeInfo.skipParens(tree.arg).hasTag(TYPECAST);
-return abstractLval(tree.arg, new TreeBuilder() {
+return abstractLval(tree.arg, tmp1 -> abstractRval(tmp1, tree.arg.type, tmp2 -> {
-public JCExpression build(final JCExpression tmp1) {
+Tag opcode = (tree.hasTag(POSTINC))
-return abstractRval(tmp1, tree.arg.type, new TreeBuilder() {
+? PLUS_ASG : MINUS_ASG;
-public JCExpression build(final JCExpression tmp2) {
+//"tmp1" and "tmp2" may refer to the same instance
-JCTree.Tag opcode = (tree.hasTag(POSTINC))
+//(for e.g. <Class>.super.<ident>). But further processing may
-? PLUS_ASG : MINUS_ASG;
+//change the components of the tree in place (see visitSelect),
-//"tmp1" and "tmp2" may refer to the same instance
+//so cloning the tree to avoid interference between the two uses:
-//(for e.g. <Class>.super.<ident>). But further processing may
+JCExpression lhs = (JCExpression)tmp1.clone();
-//change the components of the tree in place (see visitSelect),
+lhs = cast
-//so cloning the tree to avoid interference between the two uses:
+? make.TypeCast(tree.arg.type, lhs)
-JCExpression lhs = (JCExpression)tmp1.clone();
+: lhs;
-lhs = cast
+JCExpression update = makeAssignop(opcode,
-? make.TypeCast(tree.arg.type, lhs)
+lhs,
-: lhs;
+make.Literal(1));
-JCExpression update = makeAssignop(opcode,
+return makeComma(update, tmp2);
-lhs,
+}));
-make.Literal(1));
-return makeComma(update, tmp2);
-}
-});
-}
-});
 }
 public void visitUnary(JCUnary tree) {
 boolean isUpdateOperator = tree.getTag().isIncOrDecUnaryOp();
 if (isUpdateOperator && !tree.arg.type.isPrimitive()) {

changeset 42827	36468b5fa7f4
parent 42499	49b675740462
child 42828	cce89649f958