# HG changeset patch # User vromero # Date 1360315279 0 # Node ID fa256e8cfe33fb7e3781ad88a71f671b843a2044 # Parent a975ad2bfe352384091af77e6256a6c842405ce6 7167125: Two variables after the same operation in a inner class return different results Reviewed-by: jjg, mcimadamore diff -r a975ad2bfe35 -r fa256e8cfe33 langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java Fri Feb 08 09:15:27 2013 +0000 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java Fri Feb 08 09:21:19 2013 +0000 @@ -3066,55 +3066,38 @@ } public void visitAssignop(final JCAssignOp tree) { - if (!tree.lhs.type.isPrimitive() && - tree.operator.type.getReturnType().isPrimitive()) { - // 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() { - public JCTree build(final JCTree lhs) { - JCTree.Tag newTag = tree.getTag().noAssignOp(); - // Erasure (TransTypes) can change the type of - // tree.lhs. However, we can still get the - // unerased type of tree.lhs as it is stored - // in tree.type in Attr. - Symbol newOperator = rs.resolveBinaryOperator(tree.pos(), - newTag, - attrEnv, - tree.type, - tree.rhs.type); - JCExpression expr = (JCExpression)lhs; - if (expr.type != tree.type) - expr = make.TypeCast(tree.type, expr); - JCBinary opResult = make.Binary(newTag, expr, tree.rhs); - opResult.operator = newOperator; - opResult.type = newOperator.type.getReturnType(); - JCTypeCast newRhs = make.TypeCast(types.unboxedType(tree.type), - opResult); - return make.Assign((JCExpression)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); - - // If translated left hand side is an Apply, we are - // seeing an access method invocation. In this case, append - // right hand side as last argument of the access method. - if (tree.lhs.hasTag(APPLY)) { - JCMethodInvocation app = (JCMethodInvocation)tree.lhs; - // if operation is a += on strings, - // make sure to convert argument to string - JCExpression rhs = (((OperatorSymbol)tree.operator).opcode == string_add) - ? makeString(tree.rhs) - : tree.rhs; - app.args = List.of(rhs).prependList(app.args); - result = app; - } else { - result = tree; - } + final boolean boxingReq = !tree.lhs.type.isPrimitive() && + tree.operator.type.getReturnType().isPrimitive(); + + // 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() { + public JCTree build(final JCTree lhs) { + JCTree.Tag newTag = tree.getTag().noAssignOp(); + // Erasure (TransTypes) can change the type of + // tree.lhs. However, we can still get the + // unerased type of tree.lhs as it is stored + // in tree.type in Attr. + Symbol newOperator = rs.resolveBinaryOperator(tree.pos(), + newTag, + attrEnv, + tree.type, + tree.rhs.type); + JCExpression expr = (JCExpression)lhs; + if (expr.type != tree.type) + expr = make.TypeCast(tree.type, expr); + JCBinary opResult = make.Binary(newTag, expr, tree.rhs); + opResult.operator = newOperator; + opResult.type = newOperator.type.getReturnType(); + JCExpression newRhs = boxingReq ? + make.TypeCast(types.unboxedType(tree.type), + opResult) : + opResult; + return make.Assign((JCExpression)lhs, newRhs).setType(tree.type); + } + }); + result = translate(newTree); } /** Lower a tree of the form e++ or e-- where e is an object type */ diff -r a975ad2bfe35 -r fa256e8cfe33 langtools/test/tools/javac/7167125/DiffResultAfterSameOperationInnerClasses.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/7167125/DiffResultAfterSameOperationInnerClasses.java Fri Feb 08 09:21:19 2013 +0000 @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 7167125 + * @summary Two variables after the same operation in a inner class return + * different results + * @run main DiffResultAfterSameOperationInnerClasses + */ + +public class DiffResultAfterSameOperationInnerClasses { + public int i = 1; + private int j = 1; + public String s1 = "Hi, "; + private String s2 = "Hi, "; + + public static void main(String[] args) { + InnerClass inner = + new DiffResultAfterSameOperationInnerClasses().new InnerClass(); + if (!inner.test()) { + throw new AssertionError("Different results after same calculation"); + } + } + + class InnerClass { + public boolean test() { + i += i += 1; + j += j += 1; + + s1 += s1 += "dude"; + s2 += s2 += "dude"; + + System.out.println("s1 = " + s1); + System.out.println("s2 = " + s2); + + return (i == j && i == 3 && + s1.equals(s2) && s1.endsWith("Hi, Hi, dude")); + } + } +}