398 lines
15 KiB
Java
398 lines
15 KiB
Java
/*
|
|
* Copyright (c) 2016, 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
|
|
* @library /tools/lib
|
|
* @modules jdk.compiler/com.sun.tools.javac.api
|
|
* jdk.compiler/com.sun.tools.javac.code
|
|
* jdk.compiler/com.sun.tools.javac.comp
|
|
* jdk.compiler/com.sun.tools.javac.tree
|
|
* jdk.compiler/com.sun.tools.javac.util
|
|
*/
|
|
|
|
import java.io.StringWriter;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.Arrays;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.TreeSet;
|
|
|
|
import javax.tools.JavaFileObject;
|
|
import javax.tools.ToolProvider;
|
|
|
|
import com.sun.source.tree.IdentifierTree;
|
|
import com.sun.source.tree.Tree;
|
|
import com.sun.source.tree.VariableTree;
|
|
import com.sun.source.util.JavacTask;
|
|
import com.sun.tools.javac.api.JavacTool;
|
|
import com.sun.tools.javac.code.Symbol;
|
|
import com.sun.tools.javac.comp.AttrContext;
|
|
import com.sun.tools.javac.comp.Env;
|
|
import com.sun.tools.javac.comp.Lower;
|
|
import com.sun.tools.javac.tree.JCTree;
|
|
import com.sun.tools.javac.tree.JCTree.JCBlock;
|
|
import com.sun.tools.javac.tree.JCTree.JCExpression;
|
|
import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
|
|
import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
|
|
import com.sun.tools.javac.tree.JCTree.JCModifiers;
|
|
import com.sun.tools.javac.tree.JCTree.JCStatement;
|
|
import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
|
|
import com.sun.tools.javac.tree.JCTree.LetExpr;
|
|
import com.sun.tools.javac.tree.JCTree.Tag;
|
|
import com.sun.tools.javac.tree.TreeCopier;
|
|
import com.sun.tools.javac.tree.TreeInfo;
|
|
import com.sun.tools.javac.tree.TreeMaker;
|
|
import com.sun.tools.javac.tree.TreeScanner;
|
|
import com.sun.tools.javac.util.Context;
|
|
import com.sun.tools.javac.util.List;
|
|
import com.sun.tools.javac.util.Log;
|
|
import com.sun.tools.javac.util.Log.WriterKind;
|
|
import com.sun.tools.javac.util.Names;
|
|
|
|
import toolbox.ToolBox;
|
|
|
|
public class BoxingAndSuper {
|
|
public static void main(String... args) throws Exception {
|
|
new BoxingAndSuper().testSuper();
|
|
new BoxingAndSuper().testThis();
|
|
}
|
|
|
|
public void testSuper() throws Exception {
|
|
//super, same package:
|
|
runTest("package p;\n" +
|
|
"class Test extends Parent {\n" +
|
|
" protected Integer i=20;\n" +
|
|
" private Integer dump() {\n" +
|
|
" return super.i++;\n" +
|
|
" }\n" +
|
|
"}\n" +
|
|
"---" +
|
|
"package p;\n" +
|
|
"class Parent {\n" +
|
|
" protected Integer i=10;\n" +
|
|
"} ",
|
|
"p.Test.dump()java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return (let /*synthetic*/ final Integer $le0 = (Integer)super.i " +
|
|
"in (let super.i = Integer.valueOf((int)(super.i.intValue() + 1)); " +
|
|
"in $le0));\n" +
|
|
"}\n");
|
|
//qualified super, same package:
|
|
runTest("package p;\n" +
|
|
"class Test extends Parent {\n" +
|
|
" protected Integer i=20;\n" +
|
|
" class Inner {\n" +
|
|
" private Integer dump() {\n" +
|
|
" return Test.super.i++;\n" +
|
|
" }\n" +
|
|
" }\n" +
|
|
"}\n" +
|
|
"---" +
|
|
"package p;\n" +
|
|
"class Parent {\n" +
|
|
" protected Integer i=10;\n" +
|
|
"} ",
|
|
"p.Test.Inner.dump()java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return (let /*synthetic*/ final Integer $le0 = (Integer)Test.access$001(this$0) " +
|
|
"in (let Test.access$103(this$0, Integer.valueOf((int)(Test.access$201(this$0).intValue() + 1))); " +
|
|
"in $le0));\n" +
|
|
"}\n" +
|
|
"p.Test.access$001(p.Test)java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return x0.i;\n" +
|
|
"}\n" +
|
|
"p.Test.access$103(p.Test,java.lang.Integer)java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return x0.i = x1;\n" +
|
|
"}\n" +
|
|
"p.Test.access$201(p.Test)java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return x0.i;\n" +
|
|
"}\n");
|
|
//super, different packages:
|
|
runTest("package p1;\n" +
|
|
"class Test extends p2.Parent {\n" +
|
|
" protected Integer i=20;\n" +
|
|
" private Integer dump() {\n" +
|
|
" return super.i++;\n" +
|
|
" }\n" +
|
|
"}\n" +
|
|
"---" +
|
|
"package p2;\n" +
|
|
"public class Parent {\n" +
|
|
" protected Integer i=10;\n" +
|
|
"} ",
|
|
"p1.Test.dump()java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return (let /*synthetic*/ final Integer $le0 = (Integer)super.i " +
|
|
"in (let super.i = Integer.valueOf((int)(super.i.intValue() + 1)); " +
|
|
"in $le0));\n" +
|
|
"}\n");
|
|
//qualified super, different packages:
|
|
runTest("package p1;\n" +
|
|
"class Test extends p2.Parent {\n" +
|
|
" protected Integer i=20;\n" +
|
|
" class Inner {\n" +
|
|
" private Integer dump() {\n" +
|
|
" return Test.super.i++;\n" +
|
|
" }\n" +
|
|
" }\n" +
|
|
"}\n" +
|
|
"---" +
|
|
"package p2;\n" +
|
|
"public class Parent {\n" +
|
|
" protected Integer i=10;\n" +
|
|
"} ",
|
|
"p1.Test.Inner.dump()java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return (let /*synthetic*/ final Integer $le0 = (Integer)Test.access$001(this$0) " +
|
|
"in (let Test.access$103(this$0, Integer.valueOf((int)(Test.access$201(this$0).intValue() + 1))); " +
|
|
"in $le0));\n" +
|
|
"}\n" +
|
|
"p1.Test.access$001(p1.Test)java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return x0.i;\n" +
|
|
"}\n" +
|
|
"p1.Test.access$103(p1.Test,java.lang.Integer)java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return x0.i = x1;\n" +
|
|
"}\n" +
|
|
"p1.Test.access$201(p1.Test)java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return x0.i;\n" +
|
|
"}\n");
|
|
}
|
|
|
|
public void testThis() throws Exception {
|
|
String code = "public class Test {\n" +
|
|
" Integer i;\n" +
|
|
" private void dump() {\n" +
|
|
" i++;\n" +
|
|
" this.i++;\n" +
|
|
" }\n" +
|
|
"}";
|
|
String expected =
|
|
"Test.dump()void\n" +
|
|
"{\n" +
|
|
" (let /*synthetic*/ final Integer $le0 = i in (let i = Integer.valueOf((int)(i.intValue() + 1)); in $le0));\n" +
|
|
" (let /*synthetic*/ final Integer $le1 = (Integer)this.i in (let this.i = Integer.valueOf((int)(this.i.intValue() + 1)); in $le1));\n" +
|
|
"}\n";
|
|
runTest(code, expected);
|
|
//qualified this:
|
|
runTest("public class Test {\n" +
|
|
" Integer i;\n" +
|
|
" class Inner1 {\n" +
|
|
" class Inner2 {\n" +
|
|
" private Integer dump() {\n" +
|
|
" return Test.this.i++;\n" +
|
|
" }\n" +
|
|
" }\n" +
|
|
" }\n" +
|
|
"}",
|
|
"Test.Inner1.Inner2.dump()java.lang.Integer\n" +
|
|
"{\n" +
|
|
" return (let /*synthetic*/ final Integer $le0 = (Integer)this$1.this$0.i" +
|
|
" in (let this$1.this$0.i = " +
|
|
"Integer.valueOf((int)(this$1.this$0.i.intValue() + 1)); " +
|
|
"in $le0));\n" +
|
|
"}\n"
|
|
);
|
|
}
|
|
|
|
private final ToolBox tb = new ToolBox();
|
|
|
|
private void runTest(String code, String expectedDesugar) throws Exception {
|
|
List<JavaFileObject> files = List.nil();
|
|
|
|
for (String file : code.split("---")) {
|
|
files = files.prepend(new ToolBox.JavaSource(file));
|
|
}
|
|
|
|
Path classes = Paths.get("classes");
|
|
|
|
if (Files.exists(classes)) {
|
|
tb.cleanDirectory(classes);
|
|
} else {
|
|
Files.createDirectories(classes);
|
|
}
|
|
|
|
JavacTool compiler = (JavacTool) ToolProvider.getSystemJavaCompiler();
|
|
StringWriter out = new StringWriter();
|
|
Context context = new Context();
|
|
TestLower.preRegister(context);
|
|
Iterable<String> options = Arrays.asList("-d", classes.toString());
|
|
JavacTask task = (JavacTask) compiler.getTask(out, null, null, options, null, files, context);
|
|
|
|
task.generate();
|
|
|
|
out.flush();
|
|
|
|
String actual = out.toString().replace(System.getProperty("line.separator"), "\n");
|
|
|
|
if (!expectedDesugar.equals(actual)) {
|
|
throw new IllegalStateException("Actual does not match expected: " + actual);
|
|
}
|
|
}
|
|
|
|
private static final class TestLower extends Lower {
|
|
|
|
public static void preRegister(Context context) {
|
|
context.put(lowerKey, new Context.Factory<Lower>() {
|
|
public Lower make(Context c) {
|
|
return new TestLower(c);
|
|
}
|
|
});
|
|
}
|
|
|
|
private final TreeMaker make;
|
|
private final Names names;
|
|
private final Log log;
|
|
|
|
public TestLower(Context context) {
|
|
super(context);
|
|
make = TreeMaker.instance(context);
|
|
names = Names.instance(context);
|
|
log = Log.instance(context);
|
|
}
|
|
|
|
@Override
|
|
public List<JCTree> translateTopLevelClass(Env<AttrContext> env, JCTree cdef, TreeMaker make) {
|
|
List<JCTree> result = super.translateTopLevelClass(env, cdef, make);
|
|
Map<Symbol, JCMethodDecl> declarations = new HashMap<>();
|
|
Set<Symbol> toDump = new TreeSet<>(symbolComparator);
|
|
|
|
new TreeScanner() {
|
|
@Override
|
|
public void visitMethodDef(JCMethodDecl tree) {
|
|
if (tree.name.toString().startsWith("dump")) {
|
|
toDump.add(tree.sym);
|
|
}
|
|
declarations.put(tree.sym, tree);
|
|
super.visitMethodDef(tree);
|
|
}
|
|
}.scan(result);
|
|
|
|
for (Symbol d : toDump) {
|
|
dump(d, declarations, new HashSet<>());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private void dump(Symbol methodSym, Map<Symbol, JCMethodDecl> declarations, Set<Symbol> alreadyPrinted) {
|
|
if (!alreadyPrinted.add(methodSym))
|
|
return ;
|
|
|
|
JCMethodDecl method = declarations.get(methodSym);
|
|
|
|
if (method == null) {
|
|
return ;
|
|
}
|
|
|
|
log.getWriter(WriterKind.NOTICE).println(symbol2String(methodSym));
|
|
|
|
JCBlock body = new TreeCopier<Void>(make) {
|
|
private final Map<String, String> letExprRemap = new HashMap<>();
|
|
private int i;
|
|
|
|
@Override
|
|
public JCTree visitOther(Tree node, Void p) {
|
|
JCTree tree = (JCTree) node;
|
|
if (tree.hasTag(Tag.LETEXPR)) {
|
|
LetExpr le = (LetExpr) tree;
|
|
|
|
for (JCStatement var : le.defs) {
|
|
if (var.hasTag(Tag.VARDEF))
|
|
letExprRemap.put(((JCVariableDecl) var).name.toString(), "$le" + i++);
|
|
}
|
|
}
|
|
return super.visitOther(node, p);
|
|
}
|
|
|
|
@Override
|
|
public JCTree visitVariable(VariableTree node, Void p) {
|
|
String newName = letExprRemap.get(node.getName().toString());
|
|
if (newName != null) {
|
|
node = make.VarDef((JCModifiers) node.getModifiers(), names.fromString(newName), (JCExpression) node.getType(), (JCExpression) node.getInitializer());
|
|
}
|
|
return super.visitVariable(node, p);
|
|
}
|
|
|
|
@Override
|
|
public JCTree visitIdentifier(IdentifierTree node, Void p) {
|
|
String newName = letExprRemap.get(node.getName().toString());
|
|
if (newName != null) {
|
|
node = make.Ident(names.fromString(newName));
|
|
}
|
|
return super.visitIdentifier(node, p);
|
|
}
|
|
|
|
@Override
|
|
public <T extends JCTree> T copy(T tree, Void p) {
|
|
if (tree.hasTag(Tag.LETEXPR)) {
|
|
return (T) visitOther(tree, p);
|
|
}
|
|
return super.copy(tree, p);
|
|
}
|
|
|
|
}.copy(method.body);
|
|
log.getWriter(WriterKind.NOTICE).println(body.toString());
|
|
|
|
Set<Symbol> invoked = new TreeSet<>(symbolComparator);
|
|
|
|
new TreeScanner() {
|
|
@Override
|
|
public void visitApply(JCMethodInvocation tree) {
|
|
invoked.add(TreeInfo.symbol(tree.meth));
|
|
super.visitApply(tree);
|
|
}
|
|
}.scan(method);
|
|
|
|
for (Symbol search : invoked) {
|
|
dump(search, declarations, alreadyPrinted);
|
|
}
|
|
}
|
|
|
|
private String symbol2String(Symbol sym) {
|
|
switch (sym.kind) {
|
|
case TYP:
|
|
return sym.getQualifiedName().toString();
|
|
case MTH:
|
|
return symbol2String(sym.owner) + "." + sym.name + sym.type.toString();
|
|
default:
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|
|
|
|
private final Comparator<Symbol> symbolComparator = (s1, s2) -> symbol2String(s1).compareTo(symbol2String(s2));
|
|
}
|
|
|
|
}
|