stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

7167125: Two variables after the same operation in a inner class return different results

Browse Source 
Reviewed-by: jjg, mcimadamore
This commit is contained in:
Vicente Romero 2013-02-08 09:21:19 +00:00
parent 561631ea44
commit 59318f1b2e
2 changed files with 92 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java
View File

@ -3066,55 +3066,38 @@ public class Lower extends TreeTranslator {
}
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);
final boolean boxingReq = !tree.lhs.type.isPrimitive() &&
tree.operator.type.getReturnType().isPrimitive();
// 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;
}
// 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 */

61
langtools/test/tools/javac/7167125/DiffResultAfterSameOperationInnerClasses.java Normal file
View File

@ -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"));
}
}
}